muonroi-cli 1.4.0 → 1.4.1

package/src/providers/prompt-cache-key.spec.ts

@@ -1,28 +0,0 @@
-/**
- * Unit tests for computePromptCacheKey — the F1 fix for OpenAI prompt
- * cache key stability across rounds in a session.
- */
-
-import { describe, expect, it } from "vitest";
-
-import { computePromptCacheKey } from "./runtime.js";
-
-describe("computePromptCacheKey", () => {
-  it("returns a stable 32-char hex hash for a given session id", () => {
-    const a = computePromptCacheKey("sess-abc-123");
-    const b = computePromptCacheKey("sess-abc-123");
-    expect(a).toBe(b);
-    expect(a).toMatch(/^[a-f0-9]{32}$/);
-  });
-
-  it("produces different keys for different session ids", () => {
-    const a = computePromptCacheKey("sess-aaa");
-    const b = computePromptCacheKey("sess-bbb");
-    expect(a).not.toBe(b);
-  });
-
-  it("returns undefined when no session id is provided", () => {
-    expect(computePromptCacheKey(undefined)).toBeUndefined();
-    expect(computePromptCacheKey("")).toBeUndefined();
-  });
-});

package/src/providers/runtime-mock.spec.ts

@@ -1,86 +0,0 @@
-/**
- * Verifies the H1 mock-model hook in resolveModelRuntime: when
- * `globalThis.__muonroiMockModel` is set, the resolved runtime returns the
- * mock model and the test-supplied unsupportedParams/defaultProviderOptions
- * overrides flow through to ResolvedModelRuntime exactly as the real factory
- * path would surface them.
- */
-
-import { afterEach, beforeAll, describe, expect, it } from "vitest";
-
-import { installMockModel, textOnlyStream } from "../agent-harness/mock-model.js";
-import { loadCatalog } from "../models/registry.js";
-import type { ProviderFactory } from "./runtime.js";
-import { resolveModelRuntime } from "./runtime.js";
-
-function makeStubFactory(): ProviderFactory {
-  // This factory must never be invoked when the mock hook is active.
-  const fn = ((_id: string) => {
-    throw new Error("real factory should not be invoked in mock path");
-  }) as ProviderFactory;
-  fn.responses = (_id: string) => {
-    throw new Error("real factory.responses should not be invoked in mock path");
-  };
-  return fn;
-}
-
-describe("resolveModelRuntime mock hook", () => {
-  beforeAll(async () => {
-    // Catalog must be loaded so getModelInfo("gpt-5.4") returns provider=openai.
-    await loadCatalog();
-  });
-
-  let uninstall: (() => void) | null = null;
-
-  afterEach(() => {
-    uninstall?.();
-    uninstall = null;
-  });
-
-  // Use deepseek-v4-pro — catalog scope is currently deepseek + siliconflow.
-  // See src/models/catalog.README.md for why other providers were removed.
-  const MODEL_ID = "deepseek-v4-pro";
-  const PROVIDER_KEY = "deepseek";
-
-  it("returns the installed mock model without invoking the factory", () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("hi") } });
-    uninstall = handle.uninstall;
-
-    const runtime = resolveModelRuntime(makeStubFactory(), MODEL_ID);
-    expect(runtime.model).toBe(handle.model);
-  });
-
-  it("flows unsupportedParams override through to the runtime", () => {
-    const handle = installMockModel({
-      fixture: { stream: textOnlyStream("hi") },
-      unsupportedParams: ["maxOutputTokens"],
-    });
-    uninstall = handle.uninstall;
-
-    const runtime = resolveModelRuntime(makeStubFactory(), MODEL_ID);
-    expect(runtime.unsupportedParams).toEqual(["maxOutputTokens"]);
-  });
-
-  it("merges defaultProviderOptions override under the provider key", () => {
-    const handle = installMockModel({
-      fixture: { stream: textOnlyStream("hi") },
-      defaultProviderOptions: { store: false, instructions: "test-system" },
-    });
-    uninstall = handle.uninstall;
-
-    const runtime = resolveModelRuntime(makeStubFactory(), MODEL_ID);
-    expect(runtime.providerOptions?.[PROVIDER_KEY]).toMatchObject({
-      store: false,
-      instructions: "test-system",
-    });
-  });
-
-  it("uninstall() removes the mock so subsequent resolveModelRuntime calls hit the factory", () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("hi") } });
-    handle.uninstall();
-
-    expect(() => resolveModelRuntime(makeStubFactory(), MODEL_ID)).toThrow(
-      /real factory should not be invoked|real factory\.responses/,
-    );
-  });
-});

package/src/providers/runtime.ts

@@ -1,311 +0,0 @@
-import { createHash } from "node:crypto";
-import { getModelInfo } from "../models/registry.js";
-import type { ModelInfo } from "../types/index.js";
-import { getReasoningEffortForModel } from "../utils/settings.js";
-import { getProviderCapabilities } from "./capabilities.js";
-import { getProviderStrategy } from "./strategies/registry.js";
-import type { ProviderId } from "./types.js";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ProviderFactory = ((modelId: string) => any) & {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  responses?: (modelId: string) => any;
-  /** Provider-level options to merge into providerOptions[<provider>] on every call. */
-  defaultProviderOptions?: Record<string, unknown>;
-  /** AI SDK top-level call params to strip (backend doesn't accept them). */
-  unsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
-};
-
-export interface ProviderFactoryResult {
-  id: ProviderId;
-  factory: ProviderFactory;
-}
-
-export interface ResolvedModelRuntime {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  model: any;
-  modelId: string;
-  modelInfo?: ModelInfo;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  providerOptions?: any;
-  /** Top-level streamText params to omit (backend doesn't accept them). */
-  unsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
-}
-
-/**
- * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
- * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
- * baseline lives in `src/providers/strategies/<provider>.strategy.ts`.
- */
-export function createProviderFactory(
-  id: ProviderId,
-  opts: { apiKey?: string; baseURL?: string; headers?: Record<string, string> },
-): ProviderFactoryResult {
-  const strategy = getProviderStrategy(id);
-  return { id, factory: strategy.createFactory(opts) };
-}
-
-/**
- * Async variant of createProviderFactory.
- * For OpenAI: loads stored OAuth tokens (auto-refreshing if expiring) and injects
- * them as Authorization / ChatGPT-Account-ID headers so subscription-backed
- * ChatGPT Plus/Pro accounts work without an API key.
- * For Google: loads stored Gemini OAuth tokens and injects Authorization header
- * so users can authenticate via their Google account without a GOOGLE_API_KEY.
- * Falls back to API-key path when no tokens are stored.
- * All other providers: identical to createProviderFactory.
- */
-export async function createProviderFactoryAsync(
-  id: ProviderId,
-  opts: { apiKey?: string; baseURL?: string },
-): Promise<ProviderFactoryResult> {
-  try {
-    const { getOAuthProviderConfig } = await import("./auth/registry.js");
-    const cfg = await getOAuthProviderConfig(id);
-    if (cfg) {
-      const tokens = await cfg.loadTokensWithRefresh().catch(() => null);
-      if (tokens) {
-        const headers = cfg.provider.authHeaders(tokens);
-        // 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) {
-          result.factory.defaultProviderOptions = cfg.defaultProviderOptions;
-        }
-        if (cfg.unsupportedParams) {
-          result.factory.unsupportedParams = cfg.unsupportedParams;
-        }
-        return result;
-      }
-    }
-  } catch {
-    /* registry unavailable or token load failed — fall through to API key */
-  }
-
-  return createProviderFactory(id, opts);
-}
-
-/**
- * Test-harness hook: when `globalThis.__muonroiMockModel` is set, swap in a
- * mock LanguageModelV3 and skip the real provider factory entirely. The
- * providerOptions and unsupportedParams branches below run as usual so
- * cost-leak specs can verify the merged shape that streamText receives.
- * See src/agent-harness/mock-model.ts for the install helper.
- */
-interface MockRuntimeGlobals {
-  __muonroiMockModel?: unknown;
-  __muonroiMockUnsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
-  __muonroiMockDefaultProviderOptions?: Record<string, unknown>;
-  __muonroiMockModelInfo?: ModelInfo;
-}
-
-export function resolveModelRuntime(factory: ProviderFactory, modelId: string): ResolvedModelRuntime {
-  // Resolve aliases (e.g. "deepseek-v4-flash") to the provider-native id
-  // (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 as MockRuntimeGlobals;
-  const modelInfo = getModelInfo(modelId);
-  const canonicalId = modelInfo?.id ?? modelId;
-  const providerId = modelInfo?.provider as ProviderId | undefined;
-  if (!providerId && !mockGlobals.__muonroiMockModel) {
-    throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
-  }
-  const userEffort = getReasoningEffortForModel(modelId);
-  const mockModel = mockGlobals.__muonroiMockModel;
-
-  // Determine the language model + unsupportedParams + provider-level defaults.
-  // Test path: mockModel is a MockLanguageModelV3 from ai/test. Overrides for
-  // unsupportedParams / defaultProviderOptions simulate OAuth registry state.
-  // Prod path: delegate to the per-provider strategy which knows how to
-  // route via factory.responses vs factory(modelId).
-  let resolved: ResolvedModelRuntime;
-  let providerLevelDefaults: Record<string, unknown> | undefined;
-
-  if (mockModel) {
-    const mockProviderId = providerId ?? detectProviderForModel(modelId);
-    const mockModelInfo =
-      modelInfo ?? mockGlobals.__muonroiMockModelInfo ?? ({ id: canonicalId, provider: mockProviderId } as ModelInfo);
-    const caps = getProviderCapabilities(mockProviderId);
-    const providerOptions = caps.buildProviderOptions({
-      model: mockModelInfo,
-      reasoningEffort: userEffort,
-    });
-    resolved = {
-      model: mockModel,
-      modelId: canonicalId,
-      modelInfo: mockModelInfo,
-      providerOptions,
-      unsupportedParams: mockGlobals.__muonroiMockUnsupportedParams,
-    };
-    providerLevelDefaults = mockGlobals.__muonroiMockDefaultProviderOptions;
-  } else {
-    const strategy = getProviderStrategy(providerId!);
-    resolved = strategy.resolve({
-      factory,
-      modelId: canonicalId,
-      modelInfo,
-      reasoningEffort: userEffort,
-    });
-    providerLevelDefaults = factory.defaultProviderOptions;
-  }
-
-  // Merge provider-level defaults from the factory (e.g. OAuth backends inject
-  // `instructions` + `store: false` for the ChatGPT Codex API). This keeps
-  // backend-specific quirks centralized in src/providers/auth/registry.ts.
-  // 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 && resolved.modelInfo?.provider) {
-    const key = resolved.modelInfo.provider;
-    const existingForProvider = (resolved.providerOptions?.[key] as Record<string, unknown> | undefined) ?? {};
-    resolved.providerOptions = {
-      ...resolved.providerOptions,
-      [key]: {
-        ...providerLevelDefaults,
-        ...existingForProvider,
-      },
-    };
-  }
-
-  return resolved;
-}
-
-/**
- * F1: derive a stable OpenAI prompt-cache key from the session id.
- *
- * The AI SDK's agentic streamText loop sends one OpenAI call per tool round.
- * Without a stable `promptCacheKey`, OpenAI auto-hashes prompt content — so
- * the moment any later message changes (which always happens between rounds),
- * the cache is busted. Hashing session.id gives every round in the same
- * session the same key, so the unchanging system + early-message prefix
- * keeps hitting the cache. Cache TTL is short (minutes) but covers a turn.
- *
- * Returns undefined when there is no session id (e.g. headless one-shot
- * requests with no persistence) — callers must skip setting the field.
- */
-export function computePromptCacheKey(sessionId: string | undefined): string | undefined {
-  if (!sessionId) return undefined;
-  return createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
-}
-
-/**
- * G3: Build providerOptions with full per-turn context (e.g. sessionId for
- * openai.promptCacheKey). Called by orchestrator per-turn instead of at
- * resolve time, because sessionId isn't known when the model is first
- * resolved. Merges:
- *   1. Capability output (anthropic.thinking, openai/xai reasoningEffort,
- *      openai.promptCacheKey) — driven by `caps.buildProviderOptions`.
- *   2. Factory-level provider defaults (e.g. OAuth `store: false` for
- *      ChatGPT Codex backend) — same merge precedence as resolveModelRuntime.
- *
- * The merge order mirrors resolveModelRuntime: provider-level defaults are
- * applied UNDER capability output (`...defaults, ...capabilityKeys`) so
- * capability values win on conflict.
- *
- * Returns undefined when neither source produced options.
- */
-export function buildTurnProviderOptions(
-  runtime: ResolvedModelRuntime,
-  ctx: { sessionId?: string },
-): Record<string, unknown> | undefined {
-  const provider = runtime.modelInfo?.provider as ProviderId | undefined;
-  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,
-    sessionId: ctx.sessionId,
-    reasoningEffort: userEffort,
-  });
-
-  // No factory-level defaults captured on ResolvedModelRuntime — at resolve
-  // time those were already merged into `runtime.providerOptions`. To preserve
-  // them per-turn we re-merge over the capability output using the resolved
-  // values as the baseline for the same provider key.
-  let merged: Record<string, unknown> | undefined = fromCaps;
-  if (provider && runtime.providerOptions) {
-    const resolved = runtime.providerOptions as Record<string, unknown>;
-    const resolvedForProvider = resolved[provider] as Record<string, unknown> | undefined;
-    const capsForProvider = (fromCaps?.[provider] as Record<string, unknown> | undefined) ?? undefined;
-    if (resolvedForProvider || capsForProvider) {
-      merged = {
-        ...resolved,
-        ...fromCaps,
-        [provider]: {
-          ...(resolvedForProvider ?? {}),
-          ...(capsForProvider ?? {}),
-        },
-      };
-    } else {
-      merged = { ...resolved, ...fromCaps };
-    }
-  }
-
-  return merged;
-}
-
-/**
- * Returns true when a top-level streamText param should be omitted because
- * either (a) the model catalog explicitly marks it unsupported, or (b) the
- * OAuth provider registry attached `unsupportedParams` to the factory
- * (e.g. ChatGPT Codex rejects `max_output_tokens` with HTTP 400 — see G1).
- *
- * Centralizes the dropParam test so the orchestrator's sub-agent path,
- * top-level path, and cost-leak specs cannot drift apart.
- */
-export function shouldDropParam(
-  runtime: ResolvedModelRuntime,
-  param: "maxOutputTokens" | "temperature" | "topP",
-): boolean {
-  // Delegate the model-side rule to the provider capability layer:
-  //   - acceptsParam("maxOutputTokens") mirrors supportsMaxOutputTokens.
-  //   - acceptsParam("temperature"/"topP") returns false for reasoning models
-  //     (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 provider = runtime.modelInfo?.provider;
-  if (!provider) {
-    return runtime.unsupportedParams?.includes(param) ?? false;
-  }
-  const caps = getProviderCapabilities(provider as ProviderId);
-  if (!caps.acceptsParam(param, runtime.modelInfo)) {
-    return true;
-  }
-  return runtime.unsupportedParams?.includes(param) ?? false;
-}
-
-export function detectProviderForModel(modelId: string): ProviderId {
-  const info = getModelInfo(modelId);
-  if (info?.provider) {
-    return info.provider as ProviderId;
-  }
-  // Prefix-based fallback for models not in the static catalog
-  const id = modelId.toLowerCase();
-  if (id.startsWith("deepseek")) return "deepseek";
-  if (id.startsWith("gpt-") || id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4")) return "openai";
-  if (id.startsWith("gemini") || id.startsWith("models/gemini")) return "google";
-  if (id.startsWith("grok")) return "xai";
-  if (id.includes("qwen") || id.includes("glm") || id.includes("internlm")) return "siliconflow";
-  if (id.startsWith("llama") || id.startsWith("mistral") || id.startsWith("phi-")) return "ollama";
-  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: ResolvedModelRuntime): ProviderId {
-  const p = runtime.modelInfo?.provider;
-  if (!p) throw new Error(`Model "${runtime.modelId}" has no provider in catalog.`);
-  return p as ProviderId;
-}

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

@@ -1,201 +0,0 @@
-/**
- * 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.
- */
-
-interface ToolCallState {
-  index: number;
-  id?: string;
-  name?: string;
-  type?: string;
-  args: string;
-  flushed: boolean;
-}
-
-interface DeltaToolCall {
-  index?: number;
-  id?: string | null;
-  type?: string;
-  function?: {
-    name?: string | null;
-    arguments?: string | null;
-  };
-}
-
-export class SiliconflowSseRepairer {
-  private states = new Map<number, ToolCallState>();
-
-  /**
-   * 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 {
-    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: Record<string, unknown>;
-    try {
-      obj = JSON.parse(dataPayload) as Record<string, unknown>;
-    } catch {
-      return eventText;
-    }
-
-    const choice = (obj?.["choices"] as unknown[] | undefined)?.[0] as
-      | { delta?: Record<string, unknown>; finish_reason?: unknown }
-      | undefined;
-    const delta = choice?.delta;
-    if (!delta || typeof delta !== "object") return eventText;
-
-    const rawToolCalls = (delta as { tool_calls?: unknown }).tool_calls;
-    if (!Array.isArray(rawToolCalls) || rawToolCalls.length === 0) return eventText;
-
-    const tcs = rawToolCalls as DeltaToolCall[];
-    const outTcs: DeltaToolCall[] = [];
-
-    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 as { content?: unknown }).content != null ||
-      (delta as { reasoning_content?: unknown }).reasoning_content != null ||
-      choice?.finish_reason != null;
-
-    if (outTcs.length === 0 && !hasOtherContent) return "";
-
-    if (outTcs.length === 0) {
-      delete (delta as { tool_calls?: unknown }).tool_calls;
-    } else {
-      (delta as { tool_calls?: unknown }).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: typeof fetch = fetch): typeof 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<Uint8Array>({
-      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 };

package/src/providers/strategies/anthropic.strategy.ts

@@ -1,25 +0,0 @@
-/**
- * src/providers/strategies/anthropic.strategy.ts
- *
- * Phase 12.2-G4 — Anthropic provider strategy. Wraps `@ai-sdk/anthropic`
- * and exposes both `chat` and `responses` model factories.
- */
-
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { getProviderCapabilities, type ProviderCapabilities } from "../capabilities.js";
-import type { ProviderFactory } from "../runtime.js";
-import type { ProviderId } from "../types.js";
-import { BaseProviderStrategy, type CreateFactoryOpts } from "./base.strategy.js";
-
-export class AnthropicStrategy extends BaseProviderStrategy {
-  readonly id: ProviderId = "anthropic";
-  readonly capabilities: ProviderCapabilities = getProviderCapabilities("anthropic");
-
-  createFactory(opts: CreateFactoryOpts): ProviderFactory {
-    const p = createAnthropic({ apiKey: opts.apiKey, baseURL: opts.baseURL });
-    const factory: ProviderFactory = (modelId: string) => p(modelId);
-    // biome-ignore lint/suspicious/noExplicitAny: ai-sdk responses() typed any
-    factory.responses = (modelId: string) => (p as any).responses(modelId);
-    return factory;
-  }
-}