muonroi-cli 1.8.4 → 1.9.0

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

@@ -28,6 +28,12 @@ export function createOpenAICompatibleAdapter(config) {
         // placeholder because the SDK always emits an Authorization header from it.
         apiKey: config.apiKey ?? (config.oauthHeaders ? "oauth" : undefined),
         ...(config.oauthHeaders ? { headers: config.oauthHeaders } : {}),
+        transformRequestBody: (body) => {
+            const next = { ...body };
+            delete next.reasoning_effort;
+            delete next.verbosity;
+            return next;
+        },
     });
     return {
         id: config.id,
@@ -44,8 +50,9 @@ export function createOpenAICompatibleAdapter(config) {
                         : undefined,
                 });
             }
+            const cleanModel = config.model.startsWith("opencode/") ? config.model.slice(9) : config.model;
             const result = streamText({
-                model: provider(config.model),
+                model: provider(cleanModel),
                 messages: req.messages,
                 tools: req.tools,
                 toolChoice: req.toolChoice,

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

@@ -2,7 +2,7 @@
  * src/providers/pricing.ts
  *
  * Pricing lookup: catalog-first, then static fallback for providers not in catalog
- * (anthropic, openai, google — they're not in catalog.json).
+ * (anthropic, openai — they're not in catalog.json).
  * Phase 1 ships static; Phase 4 (WEB-02) adds remote fetch.
  * PROV-06 requirement.
  *
@@ -31,7 +31,7 @@ export declare const STATIC_PRICING_FALLBACK: Record<string, Record<string, Pric
 /**
  * Look up pricing for a (provider, model) pair.
  * Checks catalog first (preferred — single source of truth).
- * Falls back to static table for models not in catalog (anthropic, openai, google, legacy providers).
+ * Falls back to static table for models not in catalog (anthropic, openai, 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.
  */

package/dist/src/providers/pricing.js

@@ -2,7 +2,7 @@
  * src/providers/pricing.ts
  *
  * Pricing lookup: catalog-first, then static fallback for providers not in catalog
- * (anthropic, openai, google — they're not in catalog.json).
+ * (anthropic, openai — they're not in catalog.json).
  * Phase 1 ships static; Phase 4 (WEB-02) adds remote fetch.
  * PROV-06 requirement.
  *
@@ -10,7 +10,7 @@
  * Freshness policy: re-verify every 60 days.
  */
 import { MODELS } from "../models/registry.js";
-// Static fallback for providers not in catalog (anthropic, openai, google).
+// Static fallback for providers not in catalog (anthropic, openai).
 // verified 2026-04-29 from official provider pricing pages; cache prices
 // re-verified 2026-05-08 against deepseek-platform / openai / anthropic docs
 export const STATIC_PRICING_FALLBACK = {
@@ -51,10 +51,6 @@ export const STATIC_PRICING_FALLBACK = {
             cached_input_per_million_usd: 7.5,
         },
     },
-    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 V4 chat: $0.27/M input miss, $0.027/M input hit, $1.10/M output
         // (api-docs.deepseek.com/quick_start/pricing). Flash/Pro split below mirrors
@@ -70,12 +66,6 @@ export const STATIC_PRICING_FALLBACK = {
             output_per_million_usd: 2.19,
         },
     },
-    siliconflow: {
-        "Qwen/Qwen2.5-Coder-32B-Instruct": { input_per_million_usd: 0.18, output_per_million_usd: 0.18 }, // siliconflow.com/pricing
-        // DeepSeek models served via SiliconFlow — keep in sync with catalog.json.
-        "deepseek-ai/DeepSeek-V4-Flash": { input_per_million_usd: 0.1, output_per_million_usd: 0.4 },
-        "deepseek-ai/DeepSeek-V4-Pro": { input_per_million_usd: 2.0, output_per_million_usd: 8.0 },
-    },
     ollama: {
         // local-only — zero variable cost
         "*": { input_per_million_usd: 0, output_per_million_usd: 0 },
@@ -84,7 +74,7 @@ export const STATIC_PRICING_FALLBACK = {
 /**
  * Look up pricing for a (provider, model) pair.
  * Checks catalog first (preferred — single source of truth).
- * Falls back to static table for models not in catalog (anthropic, openai, google, legacy providers).
+ * Falls back to static table for models not in catalog (anthropic, openai, 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.
  */

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

@@ -6,6 +6,8 @@ export type ProviderFactory = ((modelId: string) => any) & {
     defaultProviderOptions?: Record<string, unknown>;
     /** AI SDK top-level call params to strip (backend doesn't accept them). */
     unsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
+    /** The provider this factory talks to. Stamped by createProviderFactory. */
+    providerId?: ProviderId;
 };
 export interface ProviderFactoryResult {
     id: ProviderId;
@@ -19,6 +21,17 @@ export interface ResolvedModelRuntime {
     /** Top-level streamText params to omit (backend doesn't accept them). */
     unsupportedParams?: ReadonlyArray<"maxOutputTokens" | "temperature" | "topP">;
 }
+/** Test seam: clear the registry between cases so entries never leak across specs. */
+export declare function __resetProviderFactoryRegistry(): void;
+/**
+ * Whether a factory for `id` was already built this session.
+ *
+ * Used by the boot warm-up to avoid CLOBBERING a factory that was built with
+ * session-specific options (custom baseURL, OAuth headers) with a plainer one.
+ */
+export declare function hasProviderFactory(id: ProviderId): boolean;
+/** The providers that have a factory this session. */
+export declare function registeredProviderIds(): ProviderId[];
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -34,8 +47,6 @@ export declare function createProviderFactory(id: ProviderId, opts: {
  * 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 Agy 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.
  */
@@ -43,7 +54,20 @@ export declare function createProviderFactoryAsync(id: ProviderId, opts: {
     apiKey?: string;
     baseURL?: string;
 }): Promise<ProviderFactoryResult>;
-export declare function resolveModelRuntime(factory: ProviderFactory, modelId: string): ResolvedModelRuntime;
+/**
+ * The factory for `modelId`'s OWN provider.
+ *
+ * Deriving the factory from the model is what makes a cross-wire structurally
+ * impossible: callers pass only a model id, so there is no second, independent
+ * value that can disagree with it. Previously the factory and the model id
+ * travelled separately and every sub-task path (compaction, classify,
+ * sub-agents) silently borrowed whatever factory its parent held — measured
+ * live 2026-07-16 (session 0c6728ba1a25): model `gpt-5.4` (openai) went out
+ * through an `xai` factory, and api.x.ai answered "The model gpt-5.4 does not
+ * exist", sending the user hunting a model-name problem that did not exist.
+ */
+export declare function factoryForModel(modelId: string): ProviderFactory;
+export declare function resolveModelRuntime(modelId: string): ResolvedModelRuntime;
 /**
  * F1: derive a stable OpenAI prompt-cache key from the session id.
  *
@@ -87,5 +111,21 @@ export declare function buildTurnProviderOptions(runtime: ResolvedModelRuntime,
  * top-level path, and cost-leak specs cannot drift apart.
  */
 export declare function shouldDropParam(runtime: ResolvedModelRuntime, param: "maxOutputTokens" | "temperature" | "topP"): boolean;
+/**
+ * Resolve the `temperature` spread for a streamText/generateText call.
+ *
+ * Returns `{}` (omit the param) when the model does not accept temperature
+ * (reasoning models, OAuth `unsupportedParams`), `{ temperature: <fixed> }`
+ * when the catalog pins a `fixed_temperature` (e.g. Moonshot/Kimi via
+ * opencode-go reject any value but `1` with "invalid temperature: only 1 is
+ * allowed for this model"), otherwise `{ temperature: <desired> }`.
+ *
+ * Every orchestrator call site that sets a temperature MUST go through this
+ * helper — inlining `temperature: 0.7` is what made every Kimi tool-loop turn
+ * fail wholesale (mirrors `resolveTemperature` used in src/council/llm.ts).
+ */
+export declare function resolveTemperatureParam(runtime: ResolvedModelRuntime, desired: number): {
+    temperature?: number;
+};
 export declare function detectProviderForModel(modelId: string): ProviderId;
 export declare function requireRuntimeProvider(runtime: ResolvedModelRuntime): ProviderId;

package/dist/src/providers/runtime.js

@@ -3,6 +3,34 @@ import { getModelInfo } from "../models/registry.js";
 import { getReasoningEffortForModel } from "../utils/settings.js";
 import { getProviderCapabilities } from "./capabilities.js";
 import { getProviderStrategy } from "./strategies/registry.js";
+/**
+ * Session-scoped registry of the most-recently-built factory per provider.
+ * It is the ONLY way a model reaches a factory: `factoryForModel` derives the
+ * factory from the model's own provider, so provider A's factory can never be
+ * paired with provider B's model (a real hazard in sub-task paths like
+ * compaction that used to inherit the parent session's factory). Boot warms an
+ * entry for every credentialed provider (see ./warm.ts). Single-orchestrator
+ * invariant (v1, see CQ-16a) makes a module-level map safe. Last-built wins, so
+ * a /model key change that rebuilds a provider's factory refreshes the entry.
+ */
+const providerFactoryRegistry = new Map();
+/** Test seam: clear the registry between cases so entries never leak across specs. */
+export function __resetProviderFactoryRegistry() {
+    providerFactoryRegistry.clear();
+}
+/**
+ * Whether a factory for `id` was already built this session.
+ *
+ * Used by the boot warm-up to avoid CLOBBERING a factory that was built with
+ * session-specific options (custom baseURL, OAuth headers) with a plainer one.
+ */
+export function hasProviderFactory(id) {
+    return providerFactoryRegistry.has(id);
+}
+/** The providers that have a factory this session. */
+export function registeredProviderIds() {
+    return [...providerFactoryRegistry.keys()];
+}
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -10,15 +38,16 @@ import { getProviderStrategy } from "./strategies/registry.js";
  */
 export function createProviderFactory(id, opts) {
     const strategy = getProviderStrategy(id);
-    return { id, factory: strategy.createFactory(opts) };
+    const factory = strategy.createFactory(opts);
+    factory.providerId = id;
+    providerFactoryRegistry.set(id, factory);
+    return { id, factory };
 }
 /**
  * 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 Agy 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.
  */
@@ -38,13 +67,12 @@ export async function createProviderFactoryAsync(id, opts) {
                 // 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).
+                // no dedicated backend (cfg.baseURL undefined).
                 //
                 // However, a user-specified baseURL in settings (e.g. switching to a
                 // different backend after an OAuth provider is killed) MUST override
-                // the hardcoded OAuth default. This lets users migrate from the old
-                // cloudcode-pa.googleapis.com endpoint to a new proxy/backend without
-                // modifying source.
+                // the hardcoded OAuth default. This lets users migrate to a new
+                // proxy/backend without modifying source.
                 const { loadUserSettings } = await import("../utils/settings.js");
                 const userSettings = loadUserSettings();
                 const userBaseURL = userSettings?.providers?.[id]?.baseURL;
@@ -66,10 +94,34 @@ export async function createProviderFactoryAsync(id, opts) {
     }
     return createProviderFactory(id, opts);
 }
-export function resolveModelRuntime(factory, modelId) {
+/**
+ * The factory for `modelId`'s OWN provider.
+ *
+ * Deriving the factory from the model is what makes a cross-wire structurally
+ * impossible: callers pass only a model id, so there is no second, independent
+ * value that can disagree with it. Previously the factory and the model id
+ * travelled separately and every sub-task path (compaction, classify,
+ * sub-agents) silently borrowed whatever factory its parent held — measured
+ * live 2026-07-16 (session 0c6728ba1a25): model `gpt-5.4` (openai) went out
+ * through an `xai` factory, and api.x.ai answered "The model gpt-5.4 does not
+ * exist", sending the user hunting a model-name problem that did not exist.
+ */
+export function factoryForModel(modelId) {
+    const providerId = getModelInfo(modelId)?.provider;
+    if (!providerId) {
+        throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
+    }
+    const factory = providerFactoryRegistry.get(providerId);
+    if (!factory) {
+        throw new Error(`No provider factory for "${providerId}" (model "${modelId}") — that provider is not authenticated this session. ` +
+            `Run /login for it, or pick a model from an authenticated provider.`);
+    }
+    return factory;
+}
+export function resolveModelRuntime(modelId) {
     // 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
+    // (e.g. "deepseek-v4-flash") BEFORE invoking the factory.
+    // Without this, DeepSeek / xAI reject the request because
     // the alias is not a valid model id on their API.
     const mockGlobals = globalThis;
     const modelInfo = getModelInfo(modelId);
@@ -105,6 +157,7 @@ export function resolveModelRuntime(factory, modelId) {
         providerLevelDefaults = mockGlobals.__muonroiMockDefaultProviderOptions;
     }
     else {
+        const factory = factoryForModel(canonicalId);
         const strategy = getProviderStrategy(providerId);
         resolved = strategy.resolve({
             factory,
@@ -229,6 +282,27 @@ export function shouldDropParam(runtime, param) {
     }
     return runtime.unsupportedParams?.includes(param) ?? false;
 }
+/**
+ * Resolve the `temperature` spread for a streamText/generateText call.
+ *
+ * Returns `{}` (omit the param) when the model does not accept temperature
+ * (reasoning models, OAuth `unsupportedParams`), `{ temperature: <fixed> }`
+ * when the catalog pins a `fixed_temperature` (e.g. Moonshot/Kimi via
+ * opencode-go reject any value but `1` with "invalid temperature: only 1 is
+ * allowed for this model"), otherwise `{ temperature: <desired> }`.
+ *
+ * Every orchestrator call site that sets a temperature MUST go through this
+ * helper — inlining `temperature: 0.7` is what made every Kimi tool-loop turn
+ * fail wholesale (mirrors `resolveTemperature` used in src/council/llm.ts).
+ */
+export function resolveTemperatureParam(runtime, desired) {
+    if (shouldDropParam(runtime, "temperature"))
+        return {};
+    const fixed = runtime.modelInfo?.fixedTemperature;
+    if (typeof fixed === "number")
+        return { temperature: fixed };
+    return { temperature: desired };
+}
 export function detectProviderForModel(modelId) {
     const info = getModelInfo(modelId);
     if (info?.provider) {
@@ -240,12 +314,12 @@ export function detectProviderForModel(modelId) {
         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.includes("glm") || id.startsWith("z-ai") || id.startsWith("zai"))
+        return "zai";
+    if (id.startsWith("opencode"))
+        return "opencode-go";
     if (id.startsWith("llama") || id.startsWith("mistral") || id.startsWith("phi-"))
         return "ollama";
     if (id.startsWith("claude"))

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

@@ -17,6 +17,22 @@ 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";
+/**
+ * Catalog ids for models reached through the OpenCode Go (Console Go) gateway
+ * carry an `opencode/` routing prefix (e.g. `opencode/deepseek-v4-flash`). That
+ * prefix is a *routing* marker, not part of the wire model name any upstream
+ * accepts — the gateway itself strips it before forwarding (see
+ * OpenCodeGoStrategy.createFactory). When a task sub-model resolved from that
+ * catalog id is run through a DIFFERENT provider's factory (e.g. the compaction
+ * proposer reusing the parent's native DeepSeek factory), the raw prefixed id
+ * would otherwise be POSTed to api.deepseek.com and rejected with HTTP 400
+ * "The supported API model names are deepseek-v4-pro or deepseek-v4-flash, but
+ * you passed opencode/deepseek-v4-flash". Stripping here — the single chokepoint
+ * every provider's resolve() flows through — makes the wire name always native.
+ * The returned `modelId` keeps the catalog id so usage/pricing attribution is
+ * unchanged; only the id handed to factory() is normalized.
+ */
+export declare function toWireModelId(modelId: string): string;
 export interface CreateFactoryOpts {
     apiKey?: string;
     baseURL?: string;

package/dist/src/providers/strategies/base.strategy.js

@@ -13,6 +13,24 @@
  *   3. Register the singleton in `strategies/registry.ts`.
  *   4. Add the ProviderId to `src/providers/types.ts` if not already present.
  */
+/**
+ * Catalog ids for models reached through the OpenCode Go (Console Go) gateway
+ * carry an `opencode/` routing prefix (e.g. `opencode/deepseek-v4-flash`). That
+ * prefix is a *routing* marker, not part of the wire model name any upstream
+ * accepts — the gateway itself strips it before forwarding (see
+ * OpenCodeGoStrategy.createFactory). When a task sub-model resolved from that
+ * catalog id is run through a DIFFERENT provider's factory (e.g. the compaction
+ * proposer reusing the parent's native DeepSeek factory), the raw prefixed id
+ * would otherwise be POSTed to api.deepseek.com and rejected with HTTP 400
+ * "The supported API model names are deepseek-v4-pro or deepseek-v4-flash, but
+ * you passed opencode/deepseek-v4-flash". Stripping here — the single chokepoint
+ * every provider's resolve() flows through — makes the wire name always native.
+ * The returned `modelId` keeps the catalog id so usage/pricing attribution is
+ * unchanged; only the id handed to factory() is normalized.
+ */
+export function toWireModelId(modelId) {
+    return modelId.startsWith("opencode/") ? modelId.slice("opencode/".length) : modelId;
+}
 /**
  * Shared base — most providers want the same `resolve` body. Subclasses
  * override only when truly different.
@@ -21,7 +39,12 @@ export class BaseProviderStrategy {
     resolve(opts) {
         const { factory, modelId, modelInfo, reasoningEffort } = opts;
         const useResponsesApi = this.capabilities.usesResponsesAPI(modelInfo);
-        const model = useResponsesApi && factory.responses ? factory.responses(modelId) : factory(modelId);
+        // Normalize the wire model name (strip the `opencode/` routing prefix) so a
+        // native provider factory never receives a gateway-routed id. See
+        // toWireModelId above. `modelId` (catalog id) is still returned below for
+        // attribution — only the id passed to factory() is normalized.
+        const wireModelId = toWireModelId(modelId);
+        const model = useResponsesApi && factory.responses ? factory.responses(wireModelId) : factory(wireModelId);
         const providerOptions = this.capabilities.buildProviderOptions({
             model: modelInfo,
             reasoningEffort,

package/dist/src/providers/strategies/{siliconflow.strategy.d.ts → opencode-go.strategy.d.ts}

@@ -1,13 +1,13 @@
 /**
- * src/providers/strategies/siliconflow.strategy.ts
+ * src/providers/strategies/opencode-go.strategy.ts
  *
- * Phase 12.2-G4 — SiliconFlow strategy via `@ai-sdk/openai-compatible`.
+ * OpenCode Go strategy via `@ai-sdk/openai-compatible`.
  */
 import { 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 declare class SiliconflowStrategy extends BaseProviderStrategy {
+export declare class OpenCodeGoStrategy extends BaseProviderStrategy {
     readonly id: ProviderId;
     readonly capabilities: ProviderCapabilities;
     createFactory(opts: CreateFactoryOpts): ProviderFactory;

package/dist/src/providers/strategies/opencode-go.strategy.js

@@ -0,0 +1,83 @@
+/**
+ * src/providers/strategies/opencode-go.strategy.ts
+ *
+ * OpenCode Go strategy via `@ai-sdk/openai-compatible`.
+ */
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { getProviderCapabilities } from "../capabilities.js";
+import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
+import { BaseProviderStrategy } from "./base.strategy.js";
+import { backfillReasoningContent, sanitizeToolCallArguments, splitParallelToolCalls, transformThinkingModeBody, transformZaiThinkingBody, } from "./thinking-mode.js";
+export class OpenCodeGoStrategy extends BaseProviderStrategy {
+    id = "opencode-go";
+    capabilities = getProviderCapabilities("opencode-go");
+    createFactory(opts) {
+        const p = createOpenAICompatible({
+            name: this.id,
+            baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS["opencode-go"],
+            apiKey: opts.apiKey ?? (opts.headers ? "oauth" : undefined),
+            ...(opts.headers ? { headers: opts.headers } : {}),
+            // DeepSeek models (common via opencode-go) do not support full json_schema,
+            // only json_object. Prevent AI SDK from sending unsupported schema.
+            supportsStructuredOutputs: false,
+            // Apply thinking-mode transform for deepseek models routed via opencode-go (e.g. deepseek-v4-flash).
+            // The opencode Console Go backend forwards to DeepSeek, which requires reasoning_content
+            // roundtrips (like direct DeepSeek). Without it, histories with tool calls produce
+            // "Upstream request failed" / invalid_request_error (observed in session 53f3c3ea4ae8).
+            // Inspect body.model (after possible prefix) to apply only when appropriate.
+            transformRequestBody: (body) => {
+                const modelInBody = body?.model || "";
+                const isDeepseekModel = modelInBody.includes("deepseek") || modelInBody.includes("v4-flash");
+                const isGlmModel = modelInBody.includes("glm");
+                let out = body;
+                if (isDeepseekModel) {
+                    out = transformThinkingModeBody(body);
+                }
+                else if (isGlmModel) {
+                    // For GLM models via opencode-go, use zai-style sanitization (reasoning backfill + tool shape).
+                    out = transformZaiThinkingBody(body);
+                }
+                else {
+                    // Other reasoning-capable models via Console Go (e.g. kimi-k2.7-code).
+                    // Verified 2026-07-02 (session 53f3c3ea4ae8): kimi histories arrive
+                    // MIXED — some assistant turns carry reasoning_content, some do not —
+                    // and Console Go rejects the request (400 "Upstream request failed").
+                    // Apply the same mixed-history reasoning backfill Z.ai uses.
+                    out = { ...body };
+                    if (Array.isArray(out.messages)) {
+                        out.messages = backfillReasoningContent(out.messages, { onlyIfMixed: true });
+                    }
+                }
+                // H3 REAL FIX — Console Go's upstream (kimi / deepseek / glm) rejects a
+                // follow-up whose history has an assistant turn with a batch of parallel
+                // tool_calls (observed 5/6 for kimi, up to 17 for glm). parallel_tool_calls
+                // below is ignored by the model, so split any multi-tool-call assistant
+                // turn into sequential single-call turns. No-op unless the failing
+                // pattern is present, so successful requests are untouched.
+                if (Array.isArray(out.messages)) {
+                    out.messages = splitParallelToolCalls(out.messages);
+                    // Repair empty/truncated tool_call arguments ("unexpected end of JSON
+                    // input" 1210 sub-cause) before they reach the Console Go upstream.
+                    out.messages = sanitizeToolCallArguments(out.messages);
+                }
+                // Additional sanitization for opencode-go (proxy can be sensitive):
+                // Force no parallel to avoid large tool result batches causing upstream failures.
+                // Drop null response_format.
+                out.parallel_tool_calls = false;
+                if ("response_format" in out) {
+                    const rf = out.response_format;
+                    if (rf == null || (typeof rf === "object" && Object.keys(rf).length === 0)) {
+                        delete out.response_format;
+                    }
+                }
+                return out;
+            },
+        });
+        return (modelId) => {
+            // Strip 'opencode/' prefix if present
+            const cleanId = modelId.startsWith("opencode/") ? modelId.slice(9) : modelId;
+            return p(cleanId);
+        };
+    }
+}
+//# sourceMappingURL=opencode-go.strategy.js.map

package/dist/src/providers/strategies/registry.js

@@ -6,19 +6,19 @@
  */
 import { AnthropicStrategy } from "./anthropic.strategy.js";
 import { DeepSeekStrategy } from "./deepseek.strategy.js";
-import { GoogleStrategy } from "./google.strategy.js";
 import { OllamaStrategy } from "./ollama.strategy.js";
 import { OpenAIStrategy } from "./openai.strategy.js";
-import { SiliconflowStrategy } from "./siliconflow.strategy.js";
+import { OpenCodeGoStrategy } from "./opencode-go.strategy.js";
 import { XAIStrategy } from "./xai.strategy.js";
+import { ZaiStrategy } from "./zai.strategy.js";
 const STRATEGIES = {
     anthropic: new AnthropicStrategy(),
     openai: new OpenAIStrategy(),
-    google: new GoogleStrategy(),
     deepseek: new DeepSeekStrategy(),
-    siliconflow: new SiliconflowStrategy(),
     xai: new XAIStrategy(),
     ollama: new OllamaStrategy(),
+    zai: new ZaiStrategy(),
+    "opencode-go": new OpenCodeGoStrategy(),
 };
 /**
  * Returns the strategy singleton for a given provider id. Throws on unknown

package/dist/src/providers/strategies/thinking-mode.d.ts

@@ -28,8 +28,117 @@
  * https://api-docs.deepseek.com/guides/thinking_mode
  */
 export declare function shouldDisableThinking(): boolean;
+interface WireMessage {
+    role?: unknown;
+    content?: unknown;
+    reasoning_content?: unknown;
+    tool_calls?: unknown;
+    [k: string]: unknown;
+}
+/**
+ * Backfill `reasoning_content: ""` onto any assistant message that lacks a
+ * (non-empty/present) one, so SiliconFlow's thinking-mode validator never
+ * sees a reasoning-less assistant turn. Assistant turns that already carry a
+ * real `reasoning_content` are left untouched.
+ *
+ * `opts.onlyIfMixed` (used by Z.ai): skip the backfill entirely when NO
+ * assistant message in the history carries a `reasoning_content` field. This
+ * guards non-thinking models (glm-4.5-air, glm-4.6v-flash) from having an
+ * unknown `reasoning_content` field injected — which would itself trigger
+ * Z.ai's 1210. Once any one assistant turn carries reasoning (i.e. the
+ * conversation is in thinking mode — confirmed by the model's own emission),
+ * the backfill brings every other assistant turn up to the same shape.
+ */
+export declare function backfillReasoningContent(messages: WireMessage[], opts?: {
+    onlyIfMixed?: boolean;
+}): WireMessage[];
+/**
+ * Split assistant messages that carry MORE THAN ONE `tool_calls` entry into a
+ * sequence of single-tool-call assistant turns, each immediately followed by
+ * its matching `role:"tool"` result. Identity (returns the same array by
+ * reference) when no assistant message has >1 tool_calls.
+ *
+ * WHY (verified from live sessions c0dcf9153803 / c1f5ca294496 and the
+ * llm-wire.log forensics on 2026-07-02): both the Z.ai GLM coding endpoint
+ * (HTTP 400 / code 1210 "Invalid API parameter") and the opencode Console Go
+ * proxy (HTTP 400 invalid_request_error "Upstream request failed") REJECT a
+ * follow-up request whose history contains an assistant turn that emitted a
+ * large batch of parallel tool_calls (observed 5, 6, 8, 12, and 17 in a single
+ * assistant message). Forcing `parallel_tool_calls:false` does NOT prevent
+ * this — the model ignores the flag and still emits batches, and the flag has
+ * no effect on assistant turns already in the history. The only reliable fix
+ * is to reshape the echoed-back history so no single assistant turn presents
+ * more than one tool_call.
+ *
+ * Safety: because this is a no-op unless an assistant turn has >1 tool_calls,
+ * it can only ever alter requests that match the known-failing pattern —
+ * requests that already succeed (≤1 tool_call per turn) are returned
+ * untouched.
+ *
+ * `reasoning_content` (when present) is kept on the FIRST split turn only and
+ * blanked to "" on the rest, so a single reasoning segment is not duplicated
+ * across the synthesized turns. Assistant `content` is likewise kept on the
+ * first and blanked on the rest.
+ */
+export declare function splitParallelToolCalls(messages: WireMessage[]): WireMessage[];
 /**
  * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
  * fully-serialized wire body right before fetch.
  */
 export declare function transformThinkingModeBody<T extends Record<string, unknown>>(body: T): T;
+/**
+ * Should the Z.ai thinking-disable escape hatch fire? Off by default — Z.ai
+ * GLM coding-plan endpoints (`api.z.ai/api/coding/paas/v4`) auto-enable
+ * thinking for reasoning-capable models (glm-4.7, glm-5.x), and we want the
+ * reasoning_content round-trip to succeed. Set `MUONROI_ZAI_DISABLE_THINKING=1`
+ * to mirror DeepSeek's fallback B (disable thinking entirely).
+ */
+export declare function shouldDisableZaiThinking(): boolean;
+/** True once a provider param-reject has flipped the session into degraded mode. */
+export declare function isProviderThinkingDegraded(): boolean;
+/** Latch degraded mode on (idempotent). Called by the retry classifier. */
+export declare function markProviderThinkingDegrade(): void;
+/** Test-only reset so the module latch doesn't leak across cases. */
+export declare function _resetProviderThinkingDegrade(): void;
+/**
+ * Ensure every assistant `tool_calls[].function.arguments` is a valid JSON
+ * STRING. GLM's coding endpoint returns a generic 1210 with the underlying
+ * detail "error parsing parameters: unexpected end of JSON input" when an
+ * assistant turn echoes back a tool call whose `arguments` is empty, missing,
+ * or truncated (verified failure mode reported by crush #1237 and opencode
+ * users — a big parallel-tool-call batch clamped by max_tokens truncates the
+ * last call's arguments mid-string). Repairs are conservative: a value that
+ * already parses as JSON is left untouched; only empty/missing/unparseable
+ * arguments are replaced with `"{}"`, and a stray object is re-stringified.
+ * No-op (returns input by reference) when nothing needs repair.
+ */
+export declare function sanitizeToolCallArguments(messages: WireMessage[]): WireMessage[];
+/**
+ * Z.ai's `transformRequestBody`. Mirrors `transformThinkingModeBody` but with
+ * one critical difference: the reasoning_content backfill is GATED on
+ * `onlyIfMixed` — it only fires once at least one assistant message in the
+ * history already carries reasoning_content. This protects non-thinking Z.ai
+ * models (glm-4.5-air, glm-4.6v-flash) which would otherwise reject the
+ * injected field with HTTP 400 / code 1210.
+ *
+ * Verified failure: session c0dcf9153803 — GLM-4.7 on the Z.ai coding
+ * endpoint. First 4 assistant turns succeeded; on the 5th streamText call
+ * (after 6 tool rounds, where intermediate assistant steps carried tool_calls
+ * WITHOUT reasoning), Z.ai rejected the whole request with code 1210
+ * "Invalid API parameter". Same class of bug as SiliconFlow 20015 (see
+ * `transformThinkingModeBody` above), but Z.ai also hosts non-thinking models
+ * on the same strategy, so the backfill must stay conditional.
+ *
+ * H3 mitigation (added after c7c4a6487847 + 94827f75a69e + c94360bac00f + c1f5ca294496):
+ * GLM coding endpoint rejects the request (often as generic 1210) when the
+ * history contains assistant turns with multiple tool_calls (even after forcing
+ * parallel_tool_calls:false — model still emitted batches of 2-5). The reject
+ * frequently manifests as stall timeout because the provider stops emitting
+ * chunks. We do extra sanitization here:
+ *   - force parallel_tool_calls:false
+ *   - drop response_format when null/empty (combo with tools is fragile)
+ *   - clamp max_tokens > 4096 down to 4096 (higher values seen in 1210s)
+ * Trade-off: more sequential tool use + slightly lower token budget.
+ */
+export declare function transformZaiThinkingBody<T extends Record<string, unknown>>(body: T): T;
+export {};