feat(sdk): let bailian provider accept base_url instead of workspace_id

Author: chenanran555

packages/sdk/src/internal/providers/bailian/adapter.ts

@@ -80,7 +80,7 @@ export class BailianAdapter implements ProviderAdapter {
 	private client: BailianClient;
 	private projectName: string;
 
-	constructor(apiKey: string, workspaceId: string, baseUrl?: string, projectName?: string) {
+	constructor(apiKey: string, workspaceId?: string, baseUrl?: string, projectName?: string) {
 		this.client = new BailianClient({ apiKey, workspaceId, baseUrl });
 		this.projectName = projectName ?? "";
 	}

packages/sdk/src/internal/providers/bailian/client.ts

@@ -1,8 +1,9 @@
+import { UserError } from "../../errors.ts";
 import { BaseApiClient } from "../base-client.ts";
 
 export interface BailianClientConfig {
 	apiKey: string;
-	workspaceId: string;
+	workspaceId?: string;
 	baseUrl?: string;
 }
 
@@ -15,7 +16,13 @@ export class BailianClient extends BaseApiClient {
 	constructor(config: BailianClientConfig) {
 		super();
 		this.apiKey = config.apiKey;
-		this.baseUrl = config.baseUrl ?? `https://${config.workspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/agentstudio`;
+		if (config.baseUrl) {
+			this.baseUrl = config.baseUrl;
+		} else if (config.workspaceId) {
+			this.baseUrl = `https://${config.workspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/agentstudio`;
+		} else {
+			throw new UserError("bailian provider requires either base_url or workspace_id");
+		}
 	}
 
 	protected headers(): Record<string, string> {

packages/sdk/src/internal/providers/bailian/config.ts

@@ -1,9 +1,17 @@
 import { z } from "zod";
 
-export const bailianConfigSchema = z.object({
-	api_key: z.string(),
-	workspace_id: z.string(),
-	base_url: z.string().optional(),
-});
+// workspace_id and base_url are both optional but at least one is required: the
+// client derives the AgentStudio base URL from workspace_id, or takes base_url
+// verbatim. Hosts that only know the full endpoint (e.g. bl's --agentstudio-base-url)
+// can supply base_url and skip workspace_id entirely.
+export const bailianConfigSchema = z
+	.object({
+		api_key: z.string(),
+		workspace_id: z.string().optional(),
+		base_url: z.string().optional(),
+	})
+	.refine((config) => Boolean(config.workspace_id || config.base_url), {
+		message: "either workspace_id or base_url is required",
+	});
 
 export type BailianConfig = z.infer<typeof bailianConfigSchema>;

packages/sdk/src/internal/providers/registry.ts

@@ -51,6 +51,22 @@ export function allProviders(): ProviderDefinition[] {
 	return Array.from(registry.values());
 }
 
+/**
+ * Validate a raw provider config against its schema, mapping zod issues to a
+ * readable UserError. Providers call `.parse()`-style validation through here so
+ * config mistakes surface as `provider 'x' config invalid: field: message` lines
+ * instead of a raw ZodError JSON dump leaking to the host's stderr.
+ */
+function parseProviderConfig(def: ProviderDefinition, rawConfig: unknown): unknown {
+	const result = def.configSchema.safeParse(rawConfig);
+	if (result.success) return result.data;
+	const details = result.error.issues.map((issue) => {
+		const path = issue.path.join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	});
+	throw new UserError(`Provider '${def.name}' config invalid:\n${details.join("\n")}`);
+}
+
 export function buildProviders(
 	providersConfig: Record<string, unknown>,
 	projectName?: string,
@@ -62,7 +78,7 @@ export function buildProviders(
 		if (!def) {
 			throw new UserError(`Unknown provider '${name}'. Registered: ${Array.from(registry.keys()).join(", ")}`);
 		}
-		const parsed = def.configSchema.parse(rawConfig);
+		const parsed = parseProviderConfig(def, rawConfig);
 		const adapter = def.createAdapter(parsed, projectName);
 		validateProviderFacets(def, adapter);
 		adapters.set(name, adapter);
@@ -78,7 +94,9 @@ export function buildProviders(
 const PROVIDER_ENV_VARS: Record<string, Record<string, { env: string[]; required: boolean }>> = {
 	bailian: {
 		api_key: { env: ["DASHSCOPE_API_KEY", "BAILIAN_API_KEY"], required: true },
-		workspace_id: { env: ["BAILIAN_WORKSPACE_ID"], required: true },
+		// Neither workspace_id nor base_url is required on its own; the config schema
+		// enforces "at least one" so a host can supply just base_url (BAILIAN_BASE_URL).
+		workspace_id: { env: ["BAILIAN_WORKSPACE_ID"], required: false },
 		base_url: { env: ["BAILIAN_BASE_URL"], required: false },
 	},
 	qoder: {
@@ -160,7 +178,7 @@ export function buildProviderFromEnv(providerName: string, projectName?: string)
 	}
 
 	const config = resolveProviderConfigFromEnv(providerName);
-	const parsed = def.configSchema.parse(config);
+	const parsed = parseProviderConfig(def, config);
 	const adapter = def.createAdapter(parsed, projectName);
 	validateProviderFacets(def, adapter);
 	return adapter;

packages/sdk/tests/unit/bailian.test.ts

@@ -38,8 +38,19 @@ describe("bailianConfigSchema", () => {
 		expect(() => bailianConfigSchema.parse({ workspace_id: "ws-123" })).toThrow();
 	});
 
-	test("rejects config missing workspace_id", () => {
-		expect(() => bailianConfigSchema.parse({ api_key: "sk-abc" })).toThrow();
+	test("accepts base_url without workspace_id", () => {
+		const result = bailianConfigSchema.parse({
+			api_key: "sk-abc",
+			base_url: "https://custom.example.com/api/v1/agentstudio",
+		});
+		expect(result.workspace_id).toBeUndefined();
+		expect(result.base_url).toBe("https://custom.example.com/api/v1/agentstudio");
+	});
+
+	test("rejects config with neither workspace_id nor base_url", () => {
+		expect(() => bailianConfigSchema.parse({ api_key: "sk-abc" })).toThrow(
+			/either workspace_id or base_url is required/,
+		);
 	});
 });
 
@@ -328,7 +339,10 @@ describe("Bailian mapEnvironment", () => {
 
 	test("rejects 'limited' networking instead of silently widening it", () => {
 		const decl: EnvironmentDecl = {
-			config: { type: "cloud", networking: { type: "limited", allowed_hosts: ["api.github.com"] } },
+			config: {
+				type: "cloud",
+				networking: { type: "limited", allowed_hosts: ["api.github.com"] },
+			},
 		};
 		// The real API rejects non-unrestricted networking; silently dropping the
 		// restriction would widen a declared egress boundary, so we must throw.