muonroi-cli 1.3.4 → 1.4.1

package/dist/src/providers/mcp-vision-bridge.test.js

@@ -28,7 +28,7 @@ describe("bridgeMcpToolResult", () => {
         expect(mockFetch).not.toHaveBeenCalled();
     });
     it("proxies screenshot results for text-only models", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -41,7 +41,7 @@ describe("bridgeMcpToolResult", () => {
         expect(mockFetch).toHaveBeenCalledTimes(1);
     });
     it("intercepts ANY MCP tool with image data, not just Playwright", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -53,7 +53,7 @@ describe("bridgeMcpToolResult", () => {
         expect(result.description).toContain("Figma design");
     });
     it("intercepts non-MCP tools with image data", async () => {
-        const fakeBase64 = "/9j/" + "A".repeat(600);
+        const fakeBase64 = `/9j/${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -80,7 +80,7 @@ describe("bridgeMcpToolResult", () => {
         expect(mockFetch).not.toHaveBeenCalled();
     });
     it("falls back gracefully when vision API fails — but still strips base64", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValue({ ok: false, status: 500 });
         const result = await bridgeMcpToolResult("mcp_playwright__browser_take_screenshot", { data: fakeBase64 }, "deepseek-v4-flash");
         // proxied=true means the orchestrator will swap in our cleaned output;
@@ -91,7 +91,7 @@ describe("bridgeMcpToolResult", () => {
         expect(serialized).not.toContain(fakeBase64);
     });
     it("strips base64 data from output when proxied", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -104,7 +104,7 @@ describe("bridgeMcpToolResult", () => {
         expect(output.screenshot).toContain("removed");
     });
     it("caches images for follow-up queries", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -122,7 +122,7 @@ describe("bridgeMcpToolResult", () => {
 describe("design context structured output", () => {
     beforeEach(() => vi.clearAllMocks());
     it("requests json_object response_format for figma/design tools", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -134,7 +134,7 @@ describe("design context structured output", () => {
         expect(body.response_format).toEqual({ type: "json_object" });
     });
     it("does NOT set response_format for non-design contexts", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "A".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"A".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({ choices: [{ message: { content: "ok" } }] }),
@@ -167,7 +167,7 @@ describe("askVisionProxy", () => {
     });
     it("answers follow-up questions about cached images", async () => {
         // Cache an image first
-        const fakeBase64 = "/9j/" + "B".repeat(600);
+        const fakeBase64 = `/9j/${"B".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -203,7 +203,7 @@ describe("askVisionProxy", () => {
 describe("analyzeImageFromSource", () => {
     beforeEach(() => vi.clearAllMocks());
     it("analyzes inline base64 images", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "C".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"C".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -230,7 +230,7 @@ describe("analyzeImageFromSource", () => {
         expect(result).toContain("Cannot resolve image source");
     });
     it("focuses analysis with a question", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "D".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"D".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({
@@ -272,7 +272,7 @@ describe("isImageFile", () => {
 describe("scrubImagePayloadsInMessages — vision description injection", () => {
     beforeEach(() => vi.clearAllMocks());
     it("injects bridged vision description into AI-SDK tool-result content", async () => {
-        const fakeBase64 = "iVBORw0KGgo" + "Z".repeat(600);
+        const fakeBase64 = `iVBORw0KGgo${"Z".repeat(600)}`;
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: async () => ({

package/dist/src/providers/openai-compatible.js

@@ -23,7 +23,11 @@ export function createOpenAICompatibleAdapter(config) {
     const provider = createOpenAICompatible({
         name: config.id,
         baseURL,
-        apiKey: config.apiKey,
+        // OAuth (subscription) path: oauthHeaders carries the Bearer token; it
+        // overrides the apiKey-derived Authorization header. apiKey falls back to a
+        // placeholder because the SDK always emits an Authorization header from it.
+        apiKey: config.apiKey ?? (config.oauthHeaders ? "oauth" : undefined),
+        ...(config.oauthHeaders ? { headers: config.oauthHeaders } : {}),
     });
     return {
         id: config.id,

package/dist/src/providers/pricing.d.ts

@@ -1,7 +1,8 @@
 /**
  * src/providers/pricing.ts
  *
- * Static pricing map: {provider, model} -> {input_per_million_usd, output_per_million_usd}.
+ * Pricing lookup: catalog-first, then static fallback for providers not in catalog
+ * (anthropic, openai, google — they're not in catalog.json).
  * Phase 1 ships static; Phase 4 (WEB-02) adds remote fetch.
  * PROV-06 requirement.
  *
@@ -26,10 +27,12 @@ export interface PricePerMillion {
      */
     cache_write_per_million_usd?: number;
 }
-export declare const PRICING: Record<string, Record<string, PricePerMillion>>;
+export declare const STATIC_PRICING_FALLBACK: Record<string, Record<string, PricePerMillion>>;
 /**
  * Look up pricing for a (provider, model) pair.
- * Returns undefined if provider or model is not in the static table.
- * Ollama uses a '*' wildcard that matches any model.
+ * Checks catalog first (preferred — single source of truth).
+ * Falls back to static table for models not in catalog (anthropic, openai, google, legacy providers).
+ * Returns undefined if provider or model is not found in either source.
+ * Ollama uses a '*' wildcard in the static table that matches any model.
  */
 export declare function lookupPricing(provider: string, model: string): PricePerMillion | undefined;

package/dist/src/providers/pricing.js

@@ -1,16 +1,19 @@
 /**
  * src/providers/pricing.ts
  *
- * Static pricing map: {provider, model} -> {input_per_million_usd, output_per_million_usd}.
+ * Pricing lookup: catalog-first, then static fallback for providers not in catalog
+ * (anthropic, openai, google — they're not in catalog.json).
  * Phase 1 ships static; Phase 4 (WEB-02) adds remote fetch.
  * PROV-06 requirement.
  *
  * Prices verified 2026-04-29 from official provider pricing pages.
  * Freshness policy: re-verify every 60 days.
  */
+import { MODELS } from "../models/registry.js";
+// Static fallback for providers not in catalog (anthropic, openai, google).
 // verified 2026-04-29 from official provider pricing pages; cache prices
 // re-verified 2026-05-08 against deepseek-platform / openai / anthropic docs
-export const PRICING = {
+export const STATIC_PRICING_FALLBACK = {
     anthropic: {
         "claude-3-5-haiku-latest": {
             input_per_million_usd: 0.8,
@@ -80,11 +83,24 @@ export const PRICING = {
 };
 /**
  * Look up pricing for a (provider, model) pair.
- * Returns undefined if provider or model is not in the static table.
- * Ollama uses a '*' wildcard that matches any model.
+ * Checks catalog first (preferred — single source of truth).
+ * Falls back to static table for models not in catalog (anthropic, openai, google, legacy providers).
+ * Returns undefined if provider or model is not found in either source.
+ * Ollama uses a '*' wildcard in the static table that matches any model.
  */
 export function lookupPricing(provider, model) {
-    const byProvider = PRICING[provider];
+    // 1. Try catalog first
+    const catalogModel = MODELS.find((m) => m.id === model && m.provider === provider);
+    if (catalogModel && catalogModel.inputPrice != null) {
+        return {
+            input_per_million_usd: catalogModel.inputPrice,
+            output_per_million_usd: catalogModel.outputPrice,
+            ...(catalogModel.cachedInputPrice != null ? { cached_input_per_million_usd: catalogModel.cachedInputPrice } : {}),
+            ...(catalogModel.cacheWritePrice != null ? { cache_write_per_million_usd: catalogModel.cacheWritePrice } : {}),
+        };
+    }
+    // 2. Fallback to static table for models not in catalog (legacy providers)
+    const byProvider = STATIC_PRICING_FALLBACK[provider];
     if (!byProvider)
         return undefined;
     return byProvider[model] ?? byProvider["*"];

package/dist/src/providers/pricing.test.js

@@ -3,34 +3,60 @@
  * Verifies lookupPricing returns correct USD/M for known (provider, model) pairs
  * and undefined for unknown models (except ollama wildcard).
  */
-import { describe, expect, it } from "vitest";
-import { lookupPricing, PRICING } from "./pricing.js";
+import { beforeAll, describe, expect, it } from "vitest";
+import { loadCatalog } from "../models/registry.js";
+import { lookupPricing, STATIC_PRICING_FALLBACK } from "./pricing.js";
 describe("lookupPricing", () => {
-    it("returns pricing for anthropic claude-3-5-sonnet-latest", () => {
+    beforeAll(async () => {
+        await loadCatalog();
+    });
+    // --- Catalog-first path ---
+    it("catalog path: deepseek-v4-flash returns pricing from catalog", () => {
+        const p = lookupPricing("deepseek", "deepseek-v4-flash");
+        expect(p).toBeDefined();
+        expect(p.input_per_million_usd).toBe(0.27);
+        expect(p.output_per_million_usd).toBe(1.1);
+        expect(p.cached_input_per_million_usd).toBe(0.027);
+    });
+    it("catalog path: deepseek-v4-pro returns pricing from catalog with cached_input", () => {
+        const p = lookupPricing("deepseek", "deepseek-v4-pro");
+        expect(p).toBeDefined();
+        expect(p.input_per_million_usd).toBe(0.55);
+        expect(p.output_per_million_usd).toBe(2.19);
+        expect(p.cached_input_per_million_usd).toBe(0.055);
+    });
+    it("catalog path: siliconflow model returns pricing from catalog", () => {
+        const p = lookupPricing("siliconflow", "deepseek-ai/DeepSeek-V4-Flash");
+        expect(p).toBeDefined();
+        expect(p.input_per_million_usd).toBe(0.14);
+        expect(p.output_per_million_usd).toBe(0.28);
+    });
+    // --- Static fallback path (providers not in catalog) ---
+    it("static fallback: anthropic claude-3-5-sonnet-latest returns pricing", () => {
         const p = lookupPricing("anthropic", "claude-3-5-sonnet-latest");
         expect(p).toBeDefined();
         expect(p.input_per_million_usd).toBe(3.0);
         expect(p.output_per_million_usd).toBe(15.0);
     });
-    it("returns pricing for openai gpt-4o", () => {
+    it("static fallback: openai gpt-4o returns pricing", () => {
         const p = lookupPricing("openai", "gpt-4o");
         expect(p).toBeDefined();
         expect(p.input_per_million_usd).toBe(2.5);
         expect(p.output_per_million_usd).toBe(10.0);
     });
-    it("returns pricing for google gemini-2.5-flash", () => {
+    it("static fallback: google gemini-2.5-flash returns pricing", () => {
         const p = lookupPricing("google", "gemini-2.5-flash");
         expect(p).toBeDefined();
         expect(p.input_per_million_usd).toBe(0.3);
     });
-    it("returns pricing for deepseek deepseek-v4-flash with cached_input rate", () => {
+    it("static fallback: deepseek deepseek-v4-flash with cached_input rate", () => {
         const p = lookupPricing("deepseek", "deepseek-v4-flash");
         expect(p).toBeDefined();
         expect(p.input_per_million_usd).toBe(0.27);
         expect(p.output_per_million_usd).toBe(1.1);
         expect(p.cached_input_per_million_usd).toBe(0.027);
     });
-    it("anthropic models surface cache_write surcharge", () => {
+    it("anthropic models surface cache_write surcharge via static fallback", () => {
         const p = lookupPricing("anthropic", "claude-3-5-sonnet-latest");
         expect(p?.cached_input_per_million_usd).toBeDefined();
         expect(p?.cache_write_per_million_usd).toBeDefined();
@@ -48,8 +74,8 @@ describe("lookupPricing", () => {
         expect(p.input_per_million_usd).toBe(0);
         expect(p.output_per_million_usd).toBe(0);
     });
-    it("PRICING map has entries for all 6 providers", () => {
-        expect(Object.keys(PRICING)).toEqual(expect.arrayContaining(["anthropic", "openai", "google", "deepseek", "siliconflow", "ollama"]));
+    it("STATIC_PRICING_FALLBACK map has entries for all 6 providers", () => {
+        expect(Object.keys(STATIC_PRICING_FALLBACK)).toEqual(expect.arrayContaining(["anthropic", "openai", "google", "deepseek", "siliconflow", "ollama"]));
     });
 });
 //# sourceMappingURL=pricing.test.js.map

package/dist/src/providers/runtime.d.ts

@@ -88,3 +88,4 @@ export declare function buildTurnProviderOptions(runtime: ResolvedModelRuntime,
  */
 export declare function shouldDropParam(runtime: ResolvedModelRuntime, param: "maxOutputTokens" | "temperature" | "topP"): boolean;
 export declare function detectProviderForModel(modelId: string): ProviderId;
+export declare function requireRuntimeProvider(runtime: ResolvedModelRuntime): ProviderId;

package/dist/src/providers/runtime.js

@@ -30,9 +30,16 @@ export async function createProviderFactoryAsync(id, opts) {
             const tokens = await cfg.loadTokensWithRefresh().catch(() => null);
             if (tokens) {
                 const headers = cfg.provider.authHeaders(tokens);
-                // OAuth subscription tokens may need a different base URL than the
-                // provider's API-key endpoint (e.g. OpenAI's ChatGPT backend).
-                const baseURL = opts.baseURL ?? cfg.baseURL;
+                // OAuth subscription tokens are only valid against the provider's OAuth
+                // backend (e.g. OpenAI's ChatGPT Codex backend), NOT its API-key
+                // endpoint. cfg.baseURL is therefore authoritative and MUST take
+                // precedence: callers (index.ts) always pass opts.baseURL = getBaseURL()
+                // (the api-key endpoint, e.g. api.openai.com), which would otherwise
+                // override the OAuth backend and produce a 401 "Missing scopes:
+                // api.responses.write" when the subscription token hits the platform
+                // API. Fall back to opts.baseURL only when the OAuth provider declares
+                // no dedicated backend (cfg.baseURL undefined, e.g. some Gemini flows).
+                const baseURL = cfg.baseURL ?? opts.baseURL;
                 const result = createProviderFactory(id, { ...opts, baseURL, headers });
                 // Attach provider-level OAuth-only defaults so downstream code can merge them.
                 if (cfg.defaultProviderOptions) {
@@ -55,11 +62,14 @@ export function resolveModelRuntime(factory, modelId) {
     // (e.g. "deepseek-ai/DeepSeek-V4-Flash") BEFORE invoking the factory.
     // Without this, SiliconFlow / DeepSeek / xAI reject the request because
     // the alias is not a valid model id on their API.
+    const mockGlobals = globalThis;
     const modelInfo = getModelInfo(modelId);
     const canonicalId = modelInfo?.id ?? modelId;
-    const providerId = (modelInfo?.provider ?? "anthropic");
+    const providerId = modelInfo?.provider;
+    if (!providerId && !mockGlobals.__muonroiMockModel) {
+        throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
+    }
     const userEffort = getReasoningEffortForModel(modelId);
-    const mockGlobals = globalThis;
     const mockModel = mockGlobals.__muonroiMockModel;
     // Determine the language model + unsupportedParams + provider-level defaults.
     // Test path: mockModel is a MockLanguageModelV3 from ai/test. Overrides for
@@ -69,15 +79,17 @@ export function resolveModelRuntime(factory, modelId) {
     let resolved;
     let providerLevelDefaults;
     if (mockModel) {
-        const caps = getProviderCapabilities(providerId);
+        const mockProviderId = providerId ?? detectProviderForModel(modelId);
+        const mockModelInfo = modelInfo ?? mockGlobals.__muonroiMockModelInfo ?? { id: canonicalId, provider: mockProviderId };
+        const caps = getProviderCapabilities(mockProviderId);
         const providerOptions = caps.buildProviderOptions({
-            model: modelInfo,
+            model: mockModelInfo,
             reasoningEffort: userEffort,
         });
         resolved = {
             model: mockModel,
             modelId: canonicalId,
-            modelInfo,
+            modelInfo: mockModelInfo,
             providerOptions,
             unsupportedParams: mockGlobals.__muonroiMockUnsupportedParams,
         };
@@ -99,8 +111,8 @@ export function resolveModelRuntime(factory, modelId) {
     // In the mock path `providerLevelDefaults` is the test-supplied override.
     // OpenAIStrategy.createFactory also seeds `{ store: true }` here on the
     // API-key path (orchestrator policy migrated in G4).
-    if (providerLevelDefaults && modelInfo?.provider) {
-        const key = modelInfo.provider;
+    if (providerLevelDefaults && resolved.modelInfo?.provider) {
+        const key = resolved.modelInfo.provider;
         const existingForProvider = resolved.providerOptions?.[key] ?? {};
         resolved.providerOptions = {
             ...resolved.providerOptions,
@@ -148,7 +160,9 @@ export function computePromptCacheKey(sessionId) {
  */
 export function buildTurnProviderOptions(runtime, ctx) {
     const provider = runtime.modelInfo?.provider;
-    const caps = getProviderCapabilities(provider ?? "anthropic");
+    if (!provider)
+        throw new Error(`Cannot build provider options — model "${runtime.modelId}" has no provider in catalog.`);
+    const caps = getProviderCapabilities(provider);
     const userEffort = getReasoningEffortForModel(runtime.modelId);
     const fromCaps = caps.buildProviderOptions({
         model: runtime.modelInfo,
@@ -196,7 +210,11 @@ export function shouldDropParam(runtime, param) {
     //     (OpenAI Responses API emits a warning and silently ignores them; we
     //     drop at the source so no future strict-mode provider hard-errors).
     // See ProviderCapabilities in src/providers/capabilities.ts.
-    const caps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
+    const provider = runtime.modelInfo?.provider;
+    if (!provider) {
+        return runtime.unsupportedParams?.includes(param) ?? false;
+    }
+    const caps = getProviderCapabilities(provider);
     if (!caps.acceptsParam(param, runtime.modelInfo)) {
         return true;
     }
@@ -221,6 +239,14 @@ export function detectProviderForModel(modelId) {
         return "siliconflow";
     if (id.startsWith("llama") || id.startsWith("mistral") || id.startsWith("phi-"))
         return "ollama";
-    return "anthropic";
+    if (id.startsWith("claude"))
+        return "anthropic";
+    throw new Error(`Cannot detect provider for model "${modelId}" — not in catalog and no prefix match. Add it to catalog.json.`);
+}
+export function requireRuntimeProvider(runtime) {
+    const p = runtime.modelInfo?.provider;
+    if (!p)
+        throw new Error(`Model "${runtime.modelId}" has no provider in catalog.`);
+    return p;
 }
 //# sourceMappingURL=runtime.js.map

package/dist/src/providers/siliconflow-sse-repair.d.ts

@@ -0,0 +1,58 @@
+/**
+ * src/providers/siliconflow-sse-repair.ts
+ *
+ * SiliconFlow streaming returns OpenAI-compatible SSE, but on Qwen3-30B
+ * tool-calling turns the FIRST `tool_calls` delta for a given index can
+ * arrive without `id` and/or `function.name` — those fields are pushed
+ * into a later chunk while the first chunk carries partial arguments.
+ *
+ * `@ai-sdk/openai-compatible@2.0.42` throws
+ * `InvalidResponseDataError("Expected 'id' to be a string.")` at
+ * `openai-compatible-chat-language-model.ts:537-541` the moment that
+ * first malformed delta lands. The user-visible failure: session
+ * 44db9105b119 (2026-05-26) crashed mid-stream right after the first
+ * grep tool call returned, with no recoverable state.
+ *
+ * Evidence chain:
+ *   - DB row `routing|Qwen/Qwen3-30B-A3B-Instruct-2507` ts=12:30:33
+ *   - DB row `tool_result|grep` ts=12:31:05.753 (last persisted event)
+ *   - TUI scrollback shows `Expected 'id' to be a string.` ts=12:31:10
+ *   - AI SDK source at the cited line confirms this is the ONLY path
+ *     to that exact error message
+ *
+ * The fix is a `fetch` interceptor for SiliconFlow streaming responses:
+ *
+ *   1. Per index, buffer (id, name, args) until BOTH id+name are seen.
+ *   2. The moment both arrive, emit ONE synthesized "first chunk" with
+ *      the accumulated arguments string.
+ *   3. After that, every subsequent delta for that index passes through
+ *      unmodified.
+ *
+ * Well-formed streams (id+name on the first chunk) hit only the
+ * pass-through path — the repairer is a no-op for them.
+ *
+ * Tests in `__tests__/siliconflow-sse-repair.test.ts` pin both the
+ * malformed and well-formed cases, plus non-SSE pass-through, [DONE]
+ * sentinel, and multi-index streams.
+ */
+export declare class SiliconflowSseRepairer {
+    private states;
+    /**
+     * Process one SSE event. Returns the repaired event text (possibly
+     * empty string to suppress the event entirely).
+     *
+     * The event text MUST include the trailing blank-line terminator
+     * (`\n\n` or `\r\n\r\n`); the caller is responsible for splitting on
+     * event boundaries.
+     */
+    repairEvent(eventText: string): string;
+}
+/**
+ * Wrap a `fetch` implementation so SiliconFlow SSE responses are
+ * repaired before reaching `@ai-sdk/openai-compatible`. Non-SSE
+ * responses are passed through untouched.
+ */
+export declare function createSiliconflowRepairFetch(base?: typeof fetch): typeof fetch;
+export declare const _internals: {
+    SiliconflowSseRepairer: typeof SiliconflowSseRepairer;
+};

package/dist/src/providers/siliconflow-sse-repair.js

@@ -0,0 +1,177 @@
+/**
+ * src/providers/siliconflow-sse-repair.ts
+ *
+ * SiliconFlow streaming returns OpenAI-compatible SSE, but on Qwen3-30B
+ * tool-calling turns the FIRST `tool_calls` delta for a given index can
+ * arrive without `id` and/or `function.name` — those fields are pushed
+ * into a later chunk while the first chunk carries partial arguments.
+ *
+ * `@ai-sdk/openai-compatible@2.0.42` throws
+ * `InvalidResponseDataError("Expected 'id' to be a string.")` at
+ * `openai-compatible-chat-language-model.ts:537-541` the moment that
+ * first malformed delta lands. The user-visible failure: session
+ * 44db9105b119 (2026-05-26) crashed mid-stream right after the first
+ * grep tool call returned, with no recoverable state.
+ *
+ * Evidence chain:
+ *   - DB row `routing|Qwen/Qwen3-30B-A3B-Instruct-2507` ts=12:30:33
+ *   - DB row `tool_result|grep` ts=12:31:05.753 (last persisted event)
+ *   - TUI scrollback shows `Expected 'id' to be a string.` ts=12:31:10
+ *   - AI SDK source at the cited line confirms this is the ONLY path
+ *     to that exact error message
+ *
+ * The fix is a `fetch` interceptor for SiliconFlow streaming responses:
+ *
+ *   1. Per index, buffer (id, name, args) until BOTH id+name are seen.
+ *   2. The moment both arrive, emit ONE synthesized "first chunk" with
+ *      the accumulated arguments string.
+ *   3. After that, every subsequent delta for that index passes through
+ *      unmodified.
+ *
+ * Well-formed streams (id+name on the first chunk) hit only the
+ * pass-through path — the repairer is a no-op for them.
+ *
+ * Tests in `__tests__/siliconflow-sse-repair.test.ts` pin both the
+ * malformed and well-formed cases, plus non-SSE pass-through, [DONE]
+ * sentinel, and multi-index streams.
+ */
+export class SiliconflowSseRepairer {
+    states = new Map();
+    /**
+     * Process one SSE event. Returns the repaired event text (possibly
+     * empty string to suppress the event entirely).
+     *
+     * The event text MUST include the trailing blank-line terminator
+     * (`\n\n` or `\r\n\r\n`); the caller is responsible for splitting on
+     * event boundaries.
+     */
+    repairEvent(eventText) {
+        const dataMatch = eventText.match(/^data: (.+?)(\r?\n|$)/m);
+        if (!dataMatch)
+            return eventText;
+        const dataPayload = dataMatch[1] ?? "";
+        if (dataPayload === "[DONE]" || dataPayload.trim() === "")
+            return eventText;
+        let obj;
+        try {
+            obj = JSON.parse(dataPayload);
+        }
+        catch {
+            return eventText;
+        }
+        const choice = obj?.["choices"]?.[0];
+        const delta = choice?.delta;
+        if (!delta || typeof delta !== "object")
+            return eventText;
+        const rawToolCalls = delta.tool_calls;
+        if (!Array.isArray(rawToolCalls) || rawToolCalls.length === 0)
+            return eventText;
+        const tcs = rawToolCalls;
+        const outTcs = [];
+        for (const tc of tcs) {
+            const idx = typeof tc.index === "number" ? tc.index : 0;
+            let st = this.states.get(idx);
+            if (!st) {
+                st = { index: idx, args: "", flushed: false };
+                this.states.set(idx, st);
+            }
+            if (st.flushed) {
+                outTcs.push(tc);
+                continue;
+            }
+            if (typeof tc.id === "string" && tc.id.length > 0)
+                st.id = tc.id;
+            if (typeof tc.function?.name === "string" && tc.function.name.length > 0)
+                st.name = tc.function.name;
+            if (typeof tc.type === "string" && tc.type.length > 0)
+                st.type = tc.type;
+            if (typeof tc.function?.arguments === "string")
+                st.args += tc.function.arguments;
+            if (st.id != null && st.name != null) {
+                outTcs.push({
+                    index: idx,
+                    id: st.id,
+                    type: st.type ?? "function",
+                    function: {
+                        name: st.name,
+                        arguments: st.args,
+                    },
+                });
+                st.flushed = true;
+                st.args = "";
+            }
+        }
+        const hasOtherContent = delta.content != null ||
+            delta.reasoning_content != null ||
+            choice?.finish_reason != null;
+        if (outTcs.length === 0 && !hasOtherContent)
+            return "";
+        if (outTcs.length === 0) {
+            delete delta.tool_calls;
+        }
+        else {
+            delta.tool_calls = outTcs;
+        }
+        const newPayload = JSON.stringify(obj);
+        return eventText.replace(/^data: .+?(\r?\n|$)/m, `data: ${newPayload}$1`);
+    }
+}
+/**
+ * Wrap a `fetch` implementation so SiliconFlow SSE responses are
+ * repaired before reaching `@ai-sdk/openai-compatible`. Non-SSE
+ * responses are passed through untouched.
+ */
+export function createSiliconflowRepairFetch(base = fetch) {
+    return async function repairFetch(input, init) {
+        const res = await base(input, init);
+        if (!res.body)
+            return res;
+        const ct = (res.headers.get("content-type") ?? "").toLowerCase();
+        if (!ct.includes("text/event-stream"))
+            return res;
+        const repairer = new SiliconflowSseRepairer();
+        const decoder = new TextDecoder();
+        const encoder = new TextEncoder();
+        let buf = "";
+        const repaired = new ReadableStream({
+            async start(controller) {
+                const reader = res.body.getReader();
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            if (buf.length > 0)
+                                controller.enqueue(encoder.encode(buf));
+                            controller.close();
+                            return;
+                        }
+                        buf += decoder.decode(value, { stream: true });
+                        for (;;) {
+                            const crlf = buf.indexOf("\r\n\r\n");
+                            const lf = buf.indexOf("\n\n");
+                            const idx = crlf === -1 ? lf : lf === -1 ? crlf : Math.min(crlf, lf);
+                            if (idx === -1)
+                                break;
+                            const sepLen = idx === crlf ? 4 : 2;
+                            const event = buf.slice(0, idx + sepLen);
+                            buf = buf.slice(idx + sepLen);
+                            const out = repairer.repairEvent(event);
+                            if (out.length > 0)
+                                controller.enqueue(encoder.encode(out));
+                        }
+                    }
+                }
+                catch (err) {
+                    controller.error(err);
+                }
+            },
+        });
+        return new Response(repaired, {
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+        });
+    };
+}
+export const _internals = { SiliconflowSseRepairer };
+//# sourceMappingURL=siliconflow-sse-repair.js.map