muonroi-cli 1.2.0

package/src/providers/patch-zod-schema.ts

@@ -0,0 +1,129 @@
+/**
+ * Patch tool schema serialization for Zod v4 + AI SDK v6 compatibility.
+ *
+ * AI SDK v6 uses `asSchema()` which handles Zod v4 Standard Schema correctly,
+ * but tools created via `tool()` helper have `parameters` (not `inputSchema`),
+ * causing `asSchema(undefined)` → empty schema `{ properties: {}, additionalProperties: false }`.
+ *
+ * Two-phase fix:
+ * 1. `captureToolSchemas()` — called when ToolSet is built, stores the
+ *    original JSON Schema keyed by tool name. Handles both `parameters`
+ *    (tool() helper) and `inputSchema` (dynamicTool/MCP) properties.
+ * 2. `patchZodToJsonSchema()` — wraps global fetch to intercept
+ *    /chat/completions requests and replace broken schemas with the
+ *    captured originals.
+ */
+
+const schemaRegistry = new Map<string, Record<string, unknown>>();
+
+/**
+ * Capture original tool schemas before AI SDK processes them.
+ * Call this after building the ToolSet, before any streamText() call.
+ *
+ * Handles both tool() tools (which have `parameters`) and dynamicTool/MCP
+ * tools (which have `inputSchema`).
+ */
+export function captureToolSchemas(tools: Record<string, unknown>): void {
+  for (const [name, def] of Object.entries(tools)) {
+    if (!def || typeof def !== "object") continue;
+    const t = def as Record<string, unknown>;
+
+    // Try `inputSchema` first (dynamicTool / MCP tools), then `parameters` (tool() helper)
+    const schemaSource = t.inputSchema ?? t.parameters;
+    if (!schemaSource) continue;
+
+    const src = schemaSource as Record<string, unknown>;
+
+    // jsonSchema() helper stores original at .jsonSchema
+    const raw = src.jsonSchema;
+    if (raw && typeof raw === "object" && (raw as any).type) {
+      schemaRegistry.set(name, { ...(raw as Record<string, unknown>) });
+      continue;
+    }
+
+    // Zod v4 schema — convert via z.toJSONSchema if available
+    try {
+      const z = require("zod");
+      if (typeof z.toJSONSchema === "function" && (src as any)._def) {
+        const converted = z.toJSONSchema(src);
+        delete converted.$schema;
+        schemaRegistry.set(name, converted);
+      }
+    } catch {}
+
+    // Standard Schema — extract via ~standard
+    if ("~standard" in src) {
+      try {
+        const std = (src as any)["~standard"];
+        if (std?.jsonSchema?.input) {
+          const jsonSch = std.jsonSchema.input({ target: "draft-07" });
+          if (jsonSch && typeof jsonSch === "object" && jsonSch.type) {
+            const clean = { ...jsonSch };
+            delete clean.$schema;
+            schemaRegistry.set(name, clean);
+          }
+        }
+      } catch {}
+    }
+  }
+}
+
+export function patchZodToJsonSchema(): void {
+  const originalFetch = globalThis.fetch;
+  if ((originalFetch as any).__zodPatched) return;
+
+  globalThis.fetch = async function patchedFetch(
+    input: string | URL | Request,
+    init?: RequestInit,
+  ): Promise<Response> {
+    if (init?.method === "POST" && init.body && typeof init.body === "string") {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (url.includes("/chat/completions")) {
+        try {
+          const body = JSON.parse(init.body);
+          if (fixBrokenToolSchemas(body)) {
+            init = { ...init, body: JSON.stringify(body) };
+          }
+        } catch {}
+      }
+    }
+    return originalFetch(input, init!);
+  } as typeof fetch;
+  (globalThis.fetch as any).__zodPatched = true;
+}
+
+function fixBrokenToolSchemas(body: Record<string, unknown>): boolean {
+  const tools = body.tools as Array<{
+    type: string;
+    function: { name: string; parameters: Record<string, unknown> };
+  }> | undefined;
+  if (!Array.isArray(tools)) return false;
+  let modified = false;
+  for (const tool of tools) {
+    const params = tool?.function?.parameters;
+    if (!params) continue;
+
+    // Remove $schema field — some providers (DeepSeek) don't like it
+    if (params.$schema) {
+      delete params.$schema;
+      modified = true;
+    }
+
+    // Check if schema is broken (empty properties or missing type)
+    const isBroken = !params.type || (
+      params.properties &&
+      typeof params.properties === "object" &&
+      Object.keys(params.properties).length === 0
+    );
+    if (!isBroken) continue;
+    const cached = schemaRegistry.get(tool.function.name);
+    if (cached) {
+      tool.function.parameters = { ...cached };
+      modified = true;
+    } else {
+      if (!params.type) params.type = "object";
+      modified = true;
+    }
+  }
+  return modified;
+}

package/src/providers/pricing.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Tests for src/providers/pricing.ts
+ * 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";
+
+describe("lookupPricing", () => {
+  it("returns pricing for anthropic claude-3-5-sonnet-latest", () => {
+    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", () => {
+    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", () => {
+    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-chat", () => {
+    const p = lookupPricing("deepseek", "deepseek-chat");
+    expect(p).toBeDefined();
+    expect(p!.input_per_million_usd).toBe(0.27);
+  });
+
+  it("returns undefined for unknown provider", () => {
+    expect(lookupPricing("nonexistent", "model")).toBeUndefined();
+  });
+
+  it("returns undefined for unknown model on a known provider (not ollama)", () => {
+    expect(lookupPricing("anthropic", "nonexistent-model")).toBeUndefined();
+  });
+
+  it("returns zero pricing for any ollama model via wildcard", () => {
+    const p = lookupPricing("ollama", "any-model-here");
+    expect(p).toBeDefined();
+    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"]),
+    );
+  });
+});

package/src/providers/pricing.ts

@@ -0,0 +1,55 @@
+/**
+ * src/providers/pricing.ts
+ *
+ * Static pricing map: {provider, model} -> {input_per_million_usd, output_per_million_usd}.
+ * 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.
+ */
+
+export interface PricePerMillion {
+  input_per_million_usd: number;
+  output_per_million_usd: number;
+}
+
+// verified 2026-04-29 from official provider pricing pages
+export const PRICING: Record<string, Record<string, PricePerMillion>> = {
+  anthropic: {
+    "claude-3-5-haiku-latest": { input_per_million_usd: 0.8, output_per_million_usd: 4.0 }, // anthropic.com/pricing
+    "claude-3-5-sonnet-latest": { input_per_million_usd: 3.0, output_per_million_usd: 15.0 }, // anthropic.com/pricing
+    "claude-3-opus-latest": { input_per_million_usd: 15.0, output_per_million_usd: 75.0 }, // anthropic.com/pricing
+  },
+  openai: {
+    "gpt-4o": { input_per_million_usd: 2.5, output_per_million_usd: 10.0 }, // openai.com/api/pricing
+    "gpt-4o-mini": { input_per_million_usd: 0.15, output_per_million_usd: 0.6 }, // openai.com/api/pricing
+    o1: { input_per_million_usd: 15.0, output_per_million_usd: 60.0 }, // openai.com/api/pricing
+  },
+  google: {
+    "gemini-2.5-flash": { input_per_million_usd: 0.3, output_per_million_usd: 2.5 }, // ai.google.dev/pricing
+    "gemini-pro-latest": { input_per_million_usd: 1.25, output_per_million_usd: 10.0 }, // ai.google.dev/pricing
+  },
+  deepseek: {
+    "deepseek-chat": { input_per_million_usd: 0.27, output_per_million_usd: 1.1 }, // api-docs.deepseek.com
+    "deepseek-reasoner": { input_per_million_usd: 0.55, output_per_million_usd: 2.19 }, // api-docs.deepseek.com
+  },
+  siliconflow: {
+    "Qwen/Qwen2.5-Coder-32B-Instruct": { input_per_million_usd: 0.18, output_per_million_usd: 0.18 }, // siliconflow.cn/pricing
+  },
+  ollama: {
+    // local-only — zero variable cost
+    "*": { input_per_million_usd: 0, output_per_million_usd: 0 },
+  },
+};
+
+/**
+ * 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.
+ */
+export function lookupPricing(provider: string, model: string): PricePerMillion | undefined {
+  const byProvider = PRICING[provider];
+  if (!byProvider) return undefined;
+  return byProvider[model] ?? byProvider["*"];
+}

package/src/providers/runtime.ts

@@ -0,0 +1,111 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createOllama } from "ollama-ai-provider-v2";
+import { getModelInfo } from "../models/registry.js";
+import type { ModelInfo } from "../types/index.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;
+};
+
+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;
+}
+
+const OPENAI_COMPATIBLE_BASE_URLS: Record<string, string> = {
+  deepseek: "https://api.deepseek.com",
+  siliconflow: "https://api.siliconflow.com/v1",
+  xai: "https://api.x.ai/v1",
+};
+
+export function createProviderFactory(
+  id: ProviderId,
+  opts: { apiKey?: string; baseURL?: string },
+): ProviderFactoryResult {
+  switch (id) {
+    case "anthropic": {
+      const p = createAnthropic({ apiKey: opts.apiKey, baseURL: opts.baseURL });
+      const factory: ProviderFactory = (modelId: string) => p(modelId);
+      factory.responses = (modelId: string) => (p as any).responses(modelId);
+      return { id, factory };
+    }
+    case "openai": {
+      const p = createOpenAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
+      return { id, factory: (modelId: string) => p(modelId) };
+    }
+    case "google": {
+      const p = createGoogleGenerativeAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
+      return { id, factory: (modelId: string) => p(modelId) };
+    }
+    case "deepseek":
+    case "siliconflow":
+    case "xai": {
+      const p = createOpenAICompatible({
+        name: id,
+        baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS[id],
+        apiKey: opts.apiKey,
+      });
+      return { id, factory: (modelId: string) => p(modelId) };
+    }
+    case "ollama": {
+      const p = createOllama({ baseURL: opts.baseURL ?? "http://localhost:11434/api" });
+      return { id, factory: (modelId: string) => p(modelId) };
+    }
+  }
+}
+
+export function resolveModelRuntime(
+  factory: ProviderFactory,
+  modelId: string,
+): ResolvedModelRuntime {
+  const model = factory(modelId);
+  const modelInfo = getModelInfo(modelId);
+
+  let providerOptions: Record<string, unknown> | undefined;
+
+  if (modelInfo?.thinkingType === "adaptive") {
+    providerOptions = { anthropic: { thinking: { type: "enabled", budgetTokens: 10_000 } } };
+  } else if (modelInfo?.thinkingType === "enabled") {
+    providerOptions = { anthropic: { thinking: { type: "enabled", budgetTokens: 8_000 } } };
+  }
+
+  if (modelInfo?.provider === "xai" && modelInfo.supportsReasoningEffort) {
+    providerOptions = {
+      ...providerOptions,
+      xai: { reasoningEffort: modelInfo.defaultReasoningEffort ?? "medium" },
+    };
+  }
+
+  return { model, modelId, modelInfo, providerOptions };
+}
+
+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/stream-loop.ts

@@ -0,0 +1,69 @@
+/**
+ * src/providers/stream-loop.ts
+ *
+ * Shared fullStream → StreamChunk loop used by all provider adapters.
+ * Extracts the common AI SDK v6 fullStream event mapping into one place.
+ *
+ * Pitfall 1 guard: tool-input-start and tool-input-delta are intentionally
+ * NOT mapped to tool-call events. They are UI streaming hints only.
+ */
+
+import { normalizeError } from "./errors.js";
+import type { ProviderStream } from "./types.js";
+
+/**
+ * Convert an AI SDK v6 fullStream async iterable into a ProviderStream.
+ * Handles text-delta, tool-call, tool-result, finish, and error events.
+ * Catches thrown errors and yields them as normalized error chunks.
+ */
+export async function* streamFromFullStream(fullStream: AsyncIterable<any>): ProviderStream {
+  try {
+    for await (const chunk of fullStream) {
+      switch (chunk.type) {
+        case "text-delta":
+          yield { kind: "text-delta", text: chunk.text };
+          break;
+
+        case "tool-call":
+          yield {
+            kind: "tool-call",
+            toolCallId: chunk.toolCallId,
+            toolName: chunk.toolName,
+            input: chunk.input,
+          };
+          break;
+
+        case "tool-result":
+          yield {
+            kind: "tool-result",
+            toolCallId: chunk.toolCallId,
+            output: (chunk as any).output,
+          };
+          break;
+
+        case "finish":
+          yield {
+            kind: "finish",
+            reason: chunk.finishReason as any,
+            usage: chunk.totalUsage ?? chunk.usage,
+          };
+          break;
+
+        case "error": {
+          const rawErr = chunk.error;
+          const error = rawErr instanceof Error ? rawErr : new Error(String(rawErr));
+          yield { kind: "error", error };
+          break;
+        }
+
+        // Pitfall 1 guard: tool-input-start and tool-input-delta are UI streaming
+        // hints. They MUST NOT yield a tool-call shape — only the final 'tool-call'
+        // event contains the complete input. Silently skip.
+        default:
+          break;
+      }
+    }
+  } catch (err) {
+    yield { kind: "error", error: normalizeError(err) };
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,111 @@
+/**
+ * src/providers/types.ts
+ *
+ * Shared streaming contracts for muonroi-cli providers.
+ * Async-generator-of-StreamChunk pattern (per CONTEXT.md),
+ * designed to be widened by the Phase 1 multi-provider Adapter interface.
+ *
+ * StreamChunk covers the AI SDK v6 fullStream event shapes we handle in Phase 0.
+ * Phase 1 may add: reasoning, source, file stream parts.
+ */
+
+/**
+ * A single chunk emitted by a provider stream.
+ * Mapped from AI SDK v6 TextStreamPart (fullStream events).
+ */
+export type StreamChunk =
+  | { kind: "text-delta"; text: string }
+  | {
+      kind: "tool-call";
+      toolCallId: string;
+      toolName: string;
+      input: unknown;
+    }
+  | {
+      kind: "tool-result";
+      toolCallId: string;
+      output: unknown;
+    }
+  | {
+      kind: "finish";
+      reason: "stop" | "length" | "tool-calls" | "error";
+      usage?: { inputTokens: number; outputTokens: number };
+    }
+  | { kind: "error"; error: Error };
+
+/**
+ * Input to a provider streaming call.
+ * apiKey is BYOK — never logged after redactor.enrollSecret() is called.
+ */
+export interface ProviderRequest {
+  /** AI model identifier, e.g. "claude-3-5-haiku-latest". */
+  model: string;
+  /** Conversation history to send to the model. */
+  messages: Array<{
+    role: "system" | "user" | "assistant";
+    content: string;
+  }>;
+  /** BYOK API key. Never log this value. */
+  apiKey: string;
+  /** Optional abort signal for cancellation. */
+  abortSignal?: AbortSignal;
+}
+
+/**
+ * An async generator that yields StreamChunk values.
+ * Used as the common return type for all provider streaming functions.
+ */
+export type ProviderStream = AsyncGenerator<StreamChunk, void, unknown>;
+
+// ---------------------------------------------------------------------------
+// Phase 1 — Multi-provider Adapter interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Supported provider identifiers.
+ * 'google' maps to Gemini via @ai-sdk/google; 'deepseek' and 'siliconflow'
+ * share the OpenAI-compatible adapter with different baseURLs.
+ */
+export type ProviderId = "anthropic" | "openai" | "google" | "deepseek" | "siliconflow" | "xai" | "ollama";
+
+/**
+ * Per-provider configuration passed to adapter factories.
+ */
+export interface ProviderConfig {
+  /** BYOK API key. Ollama may be keyless; defaults to env OLLAMA_API_KEY when present. */
+  apiKey?: string;
+  /** Base URL override for OpenAI-compatible providers (deepseek/siliconflow) + ollama VPS. */
+  baseURL?: string;
+  /** AI model identifier, e.g. "claude-3-5-haiku-latest". */
+  model: string;
+}
+
+/**
+ * Tool definition for provider tool-use calls.
+ */
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  /** JSON Schema describing the tool's input. */
+  inputSchema: Record<string, unknown>;
+}
+
+/**
+ * Unified request shape for the Adapter.stream() method.
+ * Decouples from ProviderRequest (which carries apiKey per-call).
+ */
+export interface AdapterRequest {
+  messages: ProviderRequest["messages"];
+  tools?: ToolDefinition[];
+  toolChoice?: "auto" | "required" | "none" | { type: "tool"; toolName: string };
+  abortSignal?: AbortSignal;
+}
+
+/**
+ * The single contract all provider adapters implement.
+ * Created via per-provider factory functions; registered in adapter.ts.
+ */
+export interface Adapter {
+  readonly id: ProviderId;
+  stream(req: AdapterRequest): ProviderStream;
+}