muonroi-cli 1.3.4 → 1.4.1

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,283 +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 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;
-        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>;
-}
-
-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 modelInfo = getModelInfo(modelId);
-  const canonicalId = modelInfo?.id ?? modelId;
-  const providerId = (modelInfo?.provider ?? "anthropic") as ProviderId;
-  const userEffort = getReasoningEffortForModel(modelId);
-
-  const mockGlobals = globalThis as MockRuntimeGlobals;
-  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 caps = getProviderCapabilities(providerId);
-    const providerOptions = caps.buildProviderOptions({
-      model: modelInfo,
-      reasoningEffort: userEffort,
-    });
-    resolved = {
-      model: mockModel,
-      modelId: canonicalId,
-      modelInfo,
-      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 && modelInfo?.provider) {
-    const key = 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;
-  const caps = getProviderCapabilities(provider ?? "anthropic");
-  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 caps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
-  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";
-  return "anthropic";
-}

package/src/providers/siliconflow-history.ts

@@ -1,74 +0,0 @@
-/**
- * src/providers/siliconflow-history.ts
- *
- * SiliconFlow's DeepSeek thinking-mode endpoint rejects history that contains
- * assistant `reasoning` parts unless you also serialize them as a
- * `reasoning_content` JSON field — which @ai-sdk/openai-compatible does NOT
- * do. SiliconFlow then returns HTTP 400 code 20015:
- *   "The `reasoning_content` in the thinking mode must be passed back to the API."
- *
- * Evidence captured via MUONROI_DEBUG_LLM_WIRE=1 in wire.log (request 2 had
- * partTypes=['reasoning','text'] → SiliconFlow rejected the very next call).
- *
- * Reasoning content is turn-local by design — it is the model's private
- * thinking, not durable assistant output. Stripping it from history before
- * the next turn is the documented approach for reasoning models whose API
- * does not round-trip the field, and matches how OpenAI's own o-series + the
- * native deepseek API behave: reasoning is discarded after a single turn.
- *
- * Isolation: this transform applies ONLY when providerId === "siliconflow".
- * DeepSeek's native api.deepseek.com endpoint handles reasoning differently
- * and MUST NOT be touched.
- */
-
-interface ContentPart {
-  type?: string;
-  [k: string]: unknown;
-}
-
-interface Message {
-  role?: string;
-  content?: string | ContentPart[];
-  [k: string]: unknown;
-}
-
-/**
- * Returns true if the message has assistant role + a `reasoning` part in its
- * content array. Cheap pre-filter to avoid copying messages that don't need it.
- */
-function hasReasoningPart(m: Message): boolean {
-  if (m?.role !== "assistant") return false;
-  if (!Array.isArray(m.content)) return false;
-  for (const p of m.content) {
-    if (p?.type === "reasoning") return true;
-  }
-  return false;
-}
-
-/**
- * Strip `reasoning` parts from assistant messages. Returns a new array only
- * if at least one message was rewritten; otherwise returns the input by
- * reference so downstream identity checks (e.g. in prepareStep) keep working.
- *
- * If stripping leaves an assistant message with empty content, the message
- * is kept with content=[] rather than dropped — dropping mid-history would
- * desync tool-call/tool-result pairing.
- */
-export function stripReasoningForSiliconflow<T>(messages: readonly T[]): readonly T[] {
-  let rewrote = false;
-  const out: T[] = new Array(messages.length);
-  for (let i = 0; i < messages.length; i++) {
-    const m = messages[i]!;
-    const mAny = m as unknown as Message;
-    if (!hasReasoningPart(mAny)) {
-      out[i] = m;
-      continue;
-    }
-    rewrote = true;
-    const filtered = (mAny.content as ContentPart[]).filter((p) => p?.type !== "reasoning");
-    out[i] = { ...(mAny as object), content: filtered } as T;
-  }
-  return rewrote ? out : messages;
-}
-
-export const _internals = { hasReasoningPart };

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;
-  }
-}

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

@@ -1,76 +0,0 @@
-/**
- * src/providers/strategies/base.strategy.ts
- *
- * Phase 12.2-G4: Per-provider strategy aggregating SDK client factory,
- * model resolution, and capability metadata. Each provider's quirks
- * (Responses API gating, OAuth header injection, providerOptions assembly,
- * history sanitization) live in exactly one strategy subclass — runtime.ts
- * becomes a thin dispatcher over the strategy registry.
- *
- * To add a new provider:
- *   1. Subclass `BaseProviderStrategy` in a new file under this folder.
- *   2. Implement `createFactory` (and override `resolve` only if truly different).
- *   3. Register the singleton in `strategies/registry.ts`.
- *   4. Add the ProviderId to `src/providers/types.ts` if not already present.
- */
-
-import type { ModelInfo } from "../../types/index.js";
-import type { ProviderCapabilities } from "../capabilities.js";
-import type { ProviderFactory, ResolvedModelRuntime } from "../runtime.js";
-import type { ProviderId } from "../types.js";
-
-export interface CreateFactoryOpts {
-  apiKey?: string;
-  baseURL?: string;
-  headers?: Record<string, string>;
-}
-
-export interface ResolveModelOpts {
-  factory: ProviderFactory;
-  modelId: string;
-  modelInfo: ModelInfo | undefined;
-  reasoningEffort?: "low" | "medium" | "high" | "xhigh";
-}
-
-/**
- * Per-provider strategy aggregating: SDK client factory, model resolution,
- * and capability metadata.
- */
-export interface ProviderStrategy {
-  readonly id: ProviderId;
-  readonly capabilities: ProviderCapabilities;
-
-  /** Build AI SDK provider client. */
-  createFactory(opts: CreateFactoryOpts): ProviderFactory;
-
-  /** Resolve a model to a runtime instance (model handle + options). */
-  resolve(opts: ResolveModelOpts): ResolvedModelRuntime;
-}
-
-/**
- * Shared base — most providers want the same `resolve` body. Subclasses
- * override only when truly different.
- */
-export abstract class BaseProviderStrategy implements ProviderStrategy {
-  abstract readonly id: ProviderId;
-  abstract readonly capabilities: ProviderCapabilities;
-
-  abstract createFactory(opts: CreateFactoryOpts): ProviderFactory;
-
-  resolve(opts: ResolveModelOpts): ResolvedModelRuntime {
-    const { factory, modelId, modelInfo, reasoningEffort } = opts;
-    const useResponsesApi = this.capabilities.usesResponsesAPI(modelInfo);
-    const model = useResponsesApi && factory.responses ? factory.responses(modelId) : factory(modelId);
-    const providerOptions = this.capabilities.buildProviderOptions({
-      model: modelInfo,
-      reasoningEffort,
-    });
-    return {
-      model,
-      modelId,
-      modelInfo,
-      providerOptions,
-      unsupportedParams: factory.unsupportedParams,
-    };
-  }
-}

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

@@ -1,26 +0,0 @@
-/**
- * src/providers/strategies/deepseek.strategy.ts
- *
- * Phase 12.2-G4 — DeepSeek strategy via `@ai-sdk/openai-compatible`.
- */
-
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { getProviderCapabilities, type ProviderCapabilities } from "../capabilities.js";
-import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
-import type { ProviderFactory } from "../runtime.js";
-import type { ProviderId } from "../types.js";
-import { BaseProviderStrategy, type CreateFactoryOpts } from "./base.strategy.js";
-
-export class DeepSeekStrategy extends BaseProviderStrategy {
-  readonly id: ProviderId = "deepseek";
-  readonly capabilities: ProviderCapabilities = getProviderCapabilities("deepseek");
-
-  createFactory(opts: CreateFactoryOpts): ProviderFactory {
-    const p = createOpenAICompatible({
-      name: this.id,
-      baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.deepseek,
-      apiKey: opts.apiKey,
-    });
-    return (modelId: string) => p(modelId);
-  }
-}

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

@@ -1,28 +0,0 @@
-/**
- * src/providers/strategies/google.strategy.ts
- *
- * Phase 12.2-G4 — Google Gemini strategy. Supports both API-key and OAuth
- * (Google account headers) paths.
- */
-
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-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 GoogleStrategy extends BaseProviderStrategy {
-  readonly id: ProviderId = "google";
-  readonly capabilities: ProviderCapabilities = getProviderCapabilities("google");
-
-  createFactory(opts: CreateFactoryOpts): ProviderFactory {
-    const p = opts.headers
-      ? createGoogleGenerativeAI({
-          apiKey: opts.apiKey ?? "oauth", // placeholder when using OAuth headers
-          baseURL: opts.baseURL,
-          headers: opts.headers,
-        })
-      : createGoogleGenerativeAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
-    return (modelId: string) => p(modelId);
-  }
-}

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

@@ -1,22 +0,0 @@
-/**
- * src/providers/strategies/ollama.strategy.ts
- *
- * Phase 12.2-G4 — Ollama (local model) strategy via `ollama-ai-provider-v2`.
- * No API key needed; defaults baseURL to local daemon.
- */
-
-import { createOllama } from "ollama-ai-provider-v2";
-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 OllamaStrategy extends BaseProviderStrategy {
-  readonly id: ProviderId = "ollama";
-  readonly capabilities: ProviderCapabilities = getProviderCapabilities("ollama");
-
-  createFactory(opts: CreateFactoryOpts): ProviderFactory {
-    const p = createOllama({ baseURL: opts.baseURL ?? "http://localhost:11434/api" });
-    return (modelId: string) => p(modelId);
-  }
-}

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

@@ -1,55 +0,0 @@
-/**
- * src/providers/strategies/openai.strategy.ts
- *
- * Phase 12.2-G4 — OpenAI provider strategy. Two code paths:
- *   - API-key path: standard `createOpenAI` + chat completions / responses.
- *     Defaults `store: true` on `factory.defaultProviderOptions` so logs
- *     persist in the OpenAI dashboard (orchestrator policy migrated here
- *     in G4).
- *   - OAuth (ChatGPT subscription) path: hits
- *     https://chatgpt.com/backend-api/codex with Bearer headers via the
- *     Responses API only. OAuth registry layers `store: false` +
- *     `instructions` on top of the factory defaults — see
- *     src/providers/auth/openai-oauth.ts.
- */
-
-import { createOpenAI } from "@ai-sdk/openai";
-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 OpenAIStrategy extends BaseProviderStrategy {
-  readonly id: ProviderId = "openai";
-  readonly capabilities: ProviderCapabilities = getProviderCapabilities("openai");
-
-  createFactory(opts: CreateFactoryOpts): ProviderFactory {
-    // OAuth subscription tokens cannot call api.openai.com — they must hit
-    // ChatGPT's backend (https://chatgpt.com/backend-api/codex) using the
-    // Responses API, not Chat Completions.
-    const isOAuth = !!opts.headers;
-    const p = isOAuth
-      ? createOpenAI({
-          apiKey: opts.apiKey ?? "oauth",
-          baseURL: opts.baseURL ?? "https://chatgpt.com/backend-api/codex",
-          headers: opts.headers,
-        })
-      : createOpenAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
-
-    const factory: ProviderFactory = isOAuth
-      ? // biome-ignore lint/suspicious/noExplicitAny: ai-sdk responses() typed any
-        (modelId: string) => (p as any).responses(modelId)
-      : (modelId: string) => p(modelId);
-    // biome-ignore lint/suspicious/noExplicitAny: ai-sdk responses() typed any
-    factory.responses = (modelId: string) => (p as any).responses(modelId);
-
-    // API-key path: enable `store: true` so logs persist in the OpenAI
-    // dashboard. OAuth path: providerLevelDefaults from the auth registry
-    // sets `store: false` and overrides this baseline.
-    if (!isOAuth) {
-      factory.defaultProviderOptions = { store: true };
-    }
-
-    return factory;
-  }
-}