feat(bailian): dynamic model fetching, provider hardening, and bug fixes (#420)(#421)

Add auto-fetching of available models from the DashScope API and
display them alongside the 8 static presets. Bundle the full set of
provider improvements, wiring, and tests from the bailian feature
branch.

## Dynamic Model Fetching

- packages/types/src/provider-settings.ts — register "bailian" in
  the dynamicProviders array so the model cache pipeline routes
  fetch requests
- packages/types/src/providers/bailian.ts — correct contextWindow
  from 1,048,576 to 1,000,000 for the 5 models with a 1M-token
  product specification; expand single-line pricing and cache-price
  fields to multi-line for readability
- src/api/providers/fetchers/bailian.ts — getBailianModels() fetcher
  calling DashScope /models via the standard OpenAI-compatible
  endpoint; case-insensitive exact/substring preset matching (e.g.
  "ZHIPU/GLM-5.1" matches preset "glm-5.1"); text-model keyword
  filter excluding image, embedding, speech, video, and OCR models;
  conservative defaults (8192 maxTokens, 128K context, no pricing)
  for unknown models; 10s AbortController timeout; error detail
  forwarded in thrown Error; error-body logging truncated to 500
  characters
- src/api/providers/fetchers/modelCache.ts — add "bailian" case to
  fetchModelsFromProvider() switch with exhaustive type enforcement
- src/core/webview/webviewMessageHandler.ts — add bailian candidate
  block to requestRouterModels, conditional on bailianApiKey;
  try/catch wrapper around getBailianBaseUrl to skip model fetch
  when Frankfurt or Hong Kong is selected without a workspaceId;
  flush cached models regardless of whether the key came from the
  current webview message or stored configuration; use instanceof
  Error for safe type-checking in the catch block
- src/shared/api.ts — add bailian entry to dynamicProviderExtras
  with optional apiKey and baseUrl fields
- webview-ui/src/components/settings/providers/Bailian.tsx — accept
  RouterModels prop; merge API-fetched models with static presets
  (static overwrites matching keys); pass the merged collection to
  ModelPicker; use Object.hasOwn for isCustomModel detection; trim
  model IDs so whitespace from UI input does not cause false
  custom-model detection
- webview-ui/src/components/settings/ApiOptions.tsx — pass routerModels
  to the Bailian component
- webview-ui/src/utils/__tests__/validate.spec.ts — add bailian: {}
  entry to the mock RouterModels fixture for exhaustiveness

## Provider Hardening

- src/api/providers/bailian.ts — rewrite getModel() as a three-tier
  lookup (static presets → API-fetched cache → custom model fallback)
  via getModelsFromCache; trim model IDs at the handler level so
  whitespace never reaches downstream lookups; canonicalize versioned
  and named-space API variants (e.g. "qwen3.7-max-2026-05-17",
  "kimi/kimi-k2.6") via findMatchingPreset before pricing lookup
  so every variant receives region-correct pricing; always merge
  user-configured custom model overrides regardless of whether the
  model ID matches a preset; remove sentinel "..." text injection
  for image-only messages in addPromptCaching
- src/api/providers/bailian-region.ts — getBailianBaseUrl() shared
  utility consolidating the REGION_URLS map, workspaceId validation
  for Frankfurt and Hong Kong, and a console.warn when an unknown
  region string is provided before falling back to Beijing; eliminates
  duplicate logic previously in the handler constructor and
  webviewMessageHandler

## Tests

- src/api/providers/__tests__/bailian.spec.ts — 35 handler tests
- src/api/providers/fetchers/__tests__/bailian.spec.ts — 24 fetcher
  tests (exact/substring/no-match matching, filtering, error handling,
  edge cases including network failure, AbortSignal, and non-string
  model IDs)
- webview-ui/src/components/settings/providers/__tests__/Bailian.spec.tsx
  — 5 UI merge tests (static-override priority, API-only model inclusion,
  isCustomModel detection with merged collection, whitespace trim)
- apps/vscode-e2e/src/suite/providers/bailian.test.ts — E2E smoke
  test with fetch-interceptor pattern
- apps/vscode-e2e/fixtures/bailian.json — empty fixture scaffolding

Closes #420. See #421.

Author: F915

apps/vscode-e2e/fixtures/bailian.json

@@ -0,0 +1,3 @@
+{
+	"fixtures": []
+}

apps/vscode-e2e/src/suite/providers/bailian.test.ts

@@ -0,0 +1,294 @@
+import * as assert from "assert"
+
+import { RooCodeEventName, type ClineMessage } from "@roo-code/types"
+
+import { setDefaultSuiteTimeout } from "../test-utils"
+import { waitUntilCompleted } from "../utils"
+
+const BAILIAN_API_KEY = process.env.BAILIAN_API_KEY
+
+// ---------------------------------------------------------------------------
+// Fetch interceptor
+// ---------------------------------------------------------------------------
+
+/** @typedef {{ model?: string; enable_thinking?: boolean; thinking_budget?: number; reasoning_effort?: string; probeTag?: string }} BailianRequestCapture */
+
+type BailianRequestCapture = {
+	url?: string
+	model?: string
+	enable_thinking?: boolean
+	thinking_budget?: number
+	reasoning_effort?: string
+	probeTag?: string
+}
+
+/**
+ * @param {BailianRequestCapture[]} capture
+ * @param {boolean} [passthrough]
+ * @returns {() => void} restore function
+ */
+function installBailianFetchInterceptor(capture: BailianRequestCapture[], passthrough?: boolean): () => void {
+	const original = globalThis.fetch
+
+	globalThis.fetch = async function (input: RequestInfo | URL, init?: RequestInit) {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
+
+		const isBailianUrl = url.includes("dashscope.aliyuncs.com") || url.includes("maas.aliyuncs.com")
+
+		if (isBailianUrl && url.includes("/chat/completions")) {
+			const body = init?.body ? JSON.parse(init.body as string) : {}
+			const messages = body.messages ?? []
+			const allMessagesText = JSON.stringify(messages)
+			const probeTag = allMessagesText.match(/bailian-e2e:[^"\s]+/)?.[0]
+
+			capture.push({
+				url,
+				model: body.model,
+				enable_thinking: body.enable_thinking,
+				thinking_budget: body.thinking_budget,
+				reasoning_effort: body.reasoning_effort,
+				probeTag,
+			})
+
+			if (passthrough) {
+				return original.call(globalThis, input, init)
+			}
+
+			// In mock mode, return a simple SSE response with a completion
+			const enc = new TextEncoder()
+			const body2 = new ReadableStream({
+				start(controller) {
+					controller.enqueue(
+						enc.encode(
+							`data: ${JSON.stringify({
+								id: "chatcmpl-mock",
+								object: "chat.completion.chunk",
+								created: Math.floor(Date.now() / 1000),
+								model: body.model || "qwen3.6-plus",
+								choices: [{ index: 0, delta: { content: "bailian-e2e:" }, finish_reason: null }],
+							})}\n\n`,
+						),
+					)
+					controller.enqueue(
+						enc.encode(
+							`data: ${JSON.stringify({
+								id: "chatcmpl-mock",
+								object: "chat.completion.chunk",
+								created: Math.floor(Date.now() / 1000),
+								model: body.model || "qwen3.6-plus",
+								choices: [{ index: 0, delta: { content: "mock-ok" }, finish_reason: null }],
+							})}\n\n`,
+						),
+					)
+					controller.enqueue(
+						enc.encode(
+							`data: ${JSON.stringify({
+								id: "chatcmpl-mock",
+								object: "chat.completion.chunk",
+								created: Math.floor(Date.now() / 1000),
+								model: body.model || "qwen3.6-plus",
+								choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+								usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+							})}\n\n`,
+						),
+					)
+					controller.enqueue(enc.encode("data: [DONE]\n\n"))
+					controller.close()
+				},
+			})
+			return new Response(body2, {
+				status: 200,
+				headers: { "content-type": "text/event-stream" },
+			})
+		}
+
+		return original.call(globalThis, input, init)
+	} as typeof globalThis.fetch
+
+	return () => {
+		globalThis.fetch = original
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Suite
+// ---------------------------------------------------------------------------
+
+describe("Bailian Provider", function () {
+	setDefaultSuiteTimeout(this)
+
+	/** @type {import("../../../src/extension/api").API} */
+	let api: any
+
+	before(async function () {
+		api = globalThis.api
+		if (!api) {
+			throw new Error("E2E API not found — ensure the test runner initializes globalThis.api")
+		}
+	})
+
+	// -----------------------------------------------------------------------
+	// Beijing region — basic streaming smoke test
+	// -----------------------------------------------------------------------
+
+	it("completes a task on Beijing region with Qwen model", async function () {
+		const requests: BailianRequestCapture[] = []
+		const restore = installBailianFetchInterceptor(requests)
+
+		const messages: ClineMessage[] = []
+		const messageHandler = ({ message }: { message: ClineMessage }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		}
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			await api.setConfiguration({
+				apiProvider: "bailian",
+				bailianApiKey: BAILIAN_API_KEY ?? "mock-key",
+				bailianRegion: "beijing",
+				apiModelId: "qwen3.6-plus",
+				enableReasoningEffort: false,
+			})
+
+			const taskId = await api.startNewTask({
+				configuration: { mode: "ask", autoApprovalEnabled: true },
+				text: "bailian-e2e:beijing-basic: echo 'hello'",
+			})
+			await waitUntilCompleted({ api, taskId })
+
+			const completion = messages.find((m) => m.type === "say" && m.say === "completion_result")
+			assert.ok(completion, "Task should complete successfully")
+			assert.ok(
+				completion.text?.includes("bailian-e2e:mock-ok") || completion.text?.includes("mock-ok"),
+				`Completion should contain mock response, got: ${completion.text?.slice(0, 200)}`,
+			)
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			restore()
+		}
+	})
+
+	// -----------------------------------------------------------------------
+	// DeepSeek V4 reasoning_effort parameter
+	// -----------------------------------------------------------------------
+
+	it("sends reasoning_effort for DeepSeek V4 model", async function () {
+		const requests: BailianRequestCapture[] = []
+		const restore = installBailianFetchInterceptor(requests)
+
+		const messages: ClineMessage[] = []
+		const messageHandler = ({ message }: { message: ClineMessage }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		}
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			await api.setConfiguration({
+				apiProvider: "bailian",
+				bailianApiKey: BAILIAN_API_KEY ?? "mock-key",
+				bailianRegion: "beijing",
+				apiModelId: "deepseek-v4-pro",
+				reasoningEffort: "high",
+			})
+
+			const taskId = await api.startNewTask({
+				configuration: { mode: "ask", autoApprovalEnabled: true },
+				text: "bailian-e2e:deepseek-reasoning: echo 'hello'",
+			})
+			await waitUntilCompleted({ api, taskId })
+
+			const reasoningRequest = requests.find((r) => r.reasoning_effort === "high")
+			assert.ok(reasoningRequest, "Should send reasoning_effort: high for DeepSeek V4 model")
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			restore()
+		}
+	})
+
+	// -----------------------------------------------------------------------
+	// Binary reasoning enable_thinking parameter (Qwen)
+	// -----------------------------------------------------------------------
+
+	it("sends enable_thinking for binary reasoning model (Qwen)", async function () {
+		const requests: BailianRequestCapture[] = []
+		const restore = installBailianFetchInterceptor(requests)
+
+		const messages: ClineMessage[] = []
+		const messageHandler = ({ message }: { message: ClineMessage }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		}
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			await api.setConfiguration({
+				apiProvider: "bailian",
+				bailianApiKey: BAILIAN_API_KEY ?? "mock-key",
+				bailianRegion: "beijing",
+				apiModelId: "qwen3.7-max",
+				enableReasoningEffort: true,
+			})
+
+			const taskId = await api.startNewTask({
+				configuration: { mode: "ask", autoApprovalEnabled: true },
+				text: "bailian-e2e:qwen-thinking: echo 'hello'",
+			})
+			await waitUntilCompleted({ api, taskId })
+
+			const thinkingRequest = requests.find((r) => r.enable_thinking === true)
+			assert.ok(thinkingRequest, "Should send enable_thinking: true for Qwen binary reasoning model")
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			restore()
+		}
+	})
+
+	// -----------------------------------------------------------------------
+	// Workspace ID for Frankfurt region
+	// -----------------------------------------------------------------------
+
+	it("uses Frankfurt workspaceId-based URL", async function () {
+		const requests: BailianRequestCapture[] = []
+		const restore = installBailianFetchInterceptor(requests)
+
+		const messages: ClineMessage[] = []
+		const messageHandler = ({ message }: { message: ClineMessage }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		}
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			await api.setConfiguration({
+				apiProvider: "bailian",
+				bailianApiKey: BAILIAN_API_KEY ?? "mock-key",
+				bailianRegion: "frankfurt",
+				bailianWorkspaceId: "ws-test-123",
+				apiModelId: "qwen3.6-flash",
+				enableReasoningEffort: false,
+			})
+
+			const taskId = await api.startNewTask({
+				configuration: { mode: "ask", autoApprovalEnabled: true },
+				text: "bailian-e2e:frankfurt: echo 'hello'",
+			})
+			await waitUntilCompleted({ api, taskId })
+
+			assert.ok(
+				messages.some((m) => m.type === "say" && m.say === "completion_result"),
+				"Task should complete with Frankfurt endpoint",
+			)
+			const frankfurtRequest = requests.find((r) => r.url?.includes("ws-test-123.eu-central-1.maas.aliyuncs.com"))
+			assert.ok(frankfurtRequest, "Should use workspaceId-prefixed URL for Frankfurt region")
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			restore()
+		}
+	})
+})

packages/types/src/provider-settings.ts

@@ -44,6 +44,7 @@ export const dynamicProviders = [
 	"unbound",
 	"poe",
 	"deepseek",
+	"bailian",
 	"opencode-go",
 ] as const
 
@@ -353,7 +354,16 @@ const mimoSchema = apiModelIdProviderModelSchema.extend({
 const bailianSchema = apiModelIdProviderModelSchema.extend({
 	bailianApiKey: z.string().optional(),
 	bailianRegion: z
-		.enum(["beijing", "singapore", "virginia", "frankfurt", "hongkong", "coding-plan", "token-plan", "token-plan-sgp"])
+		.enum([
+			"beijing",
+			"singapore",
+			"virginia",
+			"frankfurt",
+			"hongkong",
+			"coding-plan",
+			"token-plan",
+			"token-plan-sgp",
+		])
 		.optional(),
 	bailianWorkspaceId: z.string().optional(),
 	bailianCustomModelInfo: modelInfoSchema.nullish(),