muonroi-cli 1.8.4 → 1.8.5

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

package/dist/src/providers/strategies/thinking-mode.js

@@ -36,8 +36,21 @@ export function shouldDisableThinking() {
  * (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.
  */
-function backfillReasoningContent(messages) {
+export function backfillReasoningContent(messages, opts = {}) {
+    if (opts.onlyIfMixed) {
+        const hasAnyReasoning = messages.some((m) => m?.role === "assistant" && typeof m.reasoning_content === "string");
+        if (!hasAnyReasoning)
+            return messages;
+    }
     let mutated = false;
     const next = messages.map((m) => {
         if (m?.role !== "assistant")
@@ -63,6 +76,75 @@ function backfillReasoningContent(messages) {
     });
     return mutated ? next : messages;
 }
+/**
+ * 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 function splitParallelToolCalls(messages) {
+    const needsSplit = messages.some((m) => m?.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 1);
+    if (!needsSplit)
+        return messages;
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        const toolCalls = m?.role === "assistant" && Array.isArray(m.tool_calls) ? m.tool_calls : null;
+        if (!toolCalls || toolCalls.length <= 1) {
+            out.push(m);
+            continue;
+        }
+        // Collect the contiguous block of role:"tool" results that follows this
+        // assistant turn, keyed by tool_call_id, so each split can carry its own.
+        const resultsById = new Map();
+        let j = i + 1;
+        while (j < messages.length && messages[j]?.role === "tool") {
+            const id = messages[j].tool_call_id;
+            if (typeof id === "string")
+                resultsById.set(id, messages[j]);
+            j++;
+        }
+        for (let k = 0; k < toolCalls.length; k++) {
+            const tc = toolCalls[k];
+            const single = { ...m, tool_calls: [tc] };
+            if (k > 0) {
+                // Avoid duplicating reasoning/content across the synthesized turns.
+                if (typeof m.reasoning_content === "string")
+                    single.reasoning_content = "";
+                single.content = "";
+            }
+            out.push(single);
+            const res = typeof tc.id === "string" ? resultsById.get(tc.id) : undefined;
+            if (res)
+                out.push(res);
+        }
+        // Skip past the consumed tool-result block.
+        i = j - 1;
+    }
+    return out;
+}
 /**
  * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
  * fully-serialized wire body right before fetch.
@@ -83,4 +165,201 @@ export function transformThinkingModeBody(body) {
         return body;
     return { ...body, messages: patched };
 }
+/**
+ * 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 function shouldDisableZaiThinking() {
+    const v = process.env.MUONROI_ZAI_DISABLE_THINKING;
+    if (v !== undefined && (v === "1" || v.toLowerCase() === "true"))
+        return true;
+    // One-shot runtime degrade: once a zai/opencode coding endpoint has rejected a
+    // request with a generic param error (1210 / "Upstream request failed"), we
+    // flip thinking OFF for the remainder of the session so the retry (and every
+    // subsequent call) sends the simpler, validator-safe shape. See
+    // markProviderThinkingDegrade / retry-classifier.ts.
+    return _thinkingDegraded;
+}
+/**
+ * Runtime "degrade" latch. Set once a z.ai / opencode-go coding endpoint
+ * rejects a request with a generic, spec-undocumented param error (code 1210
+ * "Invalid API parameter" / Console Go "Upstream request failed"). Because
+ * z.ai does NOT document the exact constraint (verified 2026-07-02 against
+ * docs.z.ai/api-reference/api-code — 1210 is an intentionally generic bucket),
+ * a fully preventive client fix is impossible. The pragmatic guard is: give the
+ * request exactly one retry with a degraded-but-valid body (thinking disabled →
+ * no reasoning_content round-trip requirement; parallel tool_calls already
+ * split). retry-classifier.ts drives the one-shot semantics.
+ */
+let _thinkingDegraded = false;
+/** True once a provider param-reject has flipped the session into degraded mode. */
+export function isProviderThinkingDegraded() {
+    return _thinkingDegraded;
+}
+/** Latch degraded mode on (idempotent). Called by the retry classifier. */
+export function markProviderThinkingDegrade() {
+    _thinkingDegraded = true;
+}
+/** Test-only reset so the module latch doesn't leak across cases. */
+export function _resetProviderThinkingDegrade() {
+    _thinkingDegraded = false;
+}
+/**
+ * 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 function sanitizeToolCallArguments(messages) {
+    let mutated = false;
+    const next = messages.map((m) => {
+        if (m?.role !== "assistant")
+            return m;
+        const calls = m.tool_calls;
+        if (!Array.isArray(calls) || calls.length === 0)
+            return m;
+        let callsChanged = false;
+        const newCalls = calls.map((c) => {
+            const call = c;
+            const fn = call?.function;
+            if (!fn || typeof fn !== "object")
+                return c;
+            const args = fn.arguments;
+            let repaired;
+            if (typeof args === "string") {
+                const trimmed = args.trim();
+                if (trimmed === "") {
+                    repaired = "{}";
+                }
+                else {
+                    try {
+                        JSON.parse(trimmed);
+                    }
+                    catch {
+                        repaired = "{}";
+                    }
+                }
+            }
+            else if (args === undefined || args === null) {
+                repaired = "{}";
+            }
+            else if (typeof args === "object") {
+                // Wire shape should be a string; re-stringify a stray object.
+                try {
+                    repaired = JSON.stringify(args);
+                }
+                catch {
+                    repaired = "{}";
+                }
+            }
+            if (repaired === undefined)
+                return c;
+            callsChanged = true;
+            return { ...call, function: { ...fn, arguments: repaired } };
+        });
+        if (!callsChanged)
+            return m;
+        mutated = true;
+        return { ...m, tool_calls: newCalls };
+    });
+    return mutated ? next : messages;
+}
+/**
+ * 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 function transformZaiThinkingBody(body) {
+    const out = { ...body };
+    if (shouldDisableZaiThinking()) {
+        out.thinking = { type: "disabled" };
+    }
+    else {
+        const messages = body.messages;
+        if (Array.isArray(messages)) {
+            let patched = backfillReasoningContent(messages, { onlyIfMixed: true });
+            // Extra hardening inspired by opencode + observed Z.ai GLM behavior:
+            // Assistant messages that only contain tool_calls sometimes arrive with
+            // content: null. The coding endpoint can be strict about this shape
+            // when reasoning_content is also present.
+            patched = patched.map((m) => {
+                if (m?.role !== "assistant")
+                    return m;
+                const mm = m;
+                const hasToolCalls = Array.isArray(mm.tool_calls) && mm.tool_calls.length > 0;
+                if (hasToolCalls && (mm.content === null || mm.content === undefined)) {
+                    return { ...mm, content: "" };
+                }
+                return m;
+            });
+            // H3 REAL FIX (parallel_tool_calls:false proven ineffective — the model
+            // ignores it and still emits 8-17 tool_calls; the coding endpoint then
+            // 1210s on the echo-back). Split multi-tool-call assistant turns so no
+            // single assistant message ever presents >1 tool_call to Z.ai.
+            patched = splitParallelToolCalls(patched);
+            // Guard the "unexpected end of JSON input" 1210 sub-cause: ensure every
+            // echoed tool_call carries valid JSON arguments (empty/truncated → "{}").
+            patched = sanitizeToolCallArguments(patched);
+            if (patched !== messages) {
+                out.messages = patched;
+            }
+        }
+    }
+    // H3 mitigation (Z.ai coding 1210 on 8-17 parallel tool_calls, still seen
+    // with smaller batches in c1f5ca294496 even after the flag):
+    // Always force parallel_tool_calls:false. Kept as belt-and-suspenders even
+    // though the split above is the actual lever (the model ignores this flag).
+    out.parallel_tool_calls = false;
+    // Z.ai coding endpoint is known to return generic 1210 for certain param
+    // combinations when tools are present (observed across many sessions).
+    // - response_format (even when null) combined with tools has been implicated.
+    // - Higher max_tokens (e.g. 8192) appeared in failing requests.
+    // Clean these here so they never reach the wire for zai.
+    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;
+        }
+    }
+    if (typeof out.max_tokens === "number" && out.max_tokens > 4096) {
+        out.max_tokens = 4096;
+    }
+    // Also normalize possible camelCase variant the SDK might emit
+    if ("parallelToolCalls" in out) {
+        out.parallel_tool_calls = out.parallelToolCalls;
+        delete out.parallelToolCalls;
+    }
+    return out;
+}
 //# sourceMappingURL=thinking-mode.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * src/providers/strategies/zai.strategy.ts
+ *
+ * Z.ai 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 ZaiStrategy extends BaseProviderStrategy {
+    readonly id: ProviderId;
+    readonly capabilities: ProviderCapabilities;
+    createFactory(opts: CreateFactoryOpts): ProviderFactory;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * src/providers/strategies/zai.strategy.ts
+ *
+ * Z.ai 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 { transformZaiThinkingBody } from "./thinking-mode.js";
+export class ZaiStrategy extends BaseProviderStrategy {
+    id = "zai";
+    capabilities = getProviderCapabilities("zai");
+    createFactory(opts) {
+        const p = createOpenAICompatible({
+            name: this.id,
+            baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.zai,
+            apiKey: opts.apiKey ?? (opts.headers ? "oauth" : undefined),
+            ...(opts.headers ? { headers: opts.headers } : {}),
+            // Many Z.ai users (especially Coding Plan) hit 1210 / empty responses
+            // when using the wrong baseURL or when the SDK sends extra fields.
+            // Default is the coding/paas/v4 endpoint (matching opencode recommendations).
+            // Users can override via --base-url or provider config for the standard paas.
+            // Z.ai coding endpoint (api.z.ai/api/coding/paas/v4) auto-enables
+            // thinking for GLM-4.7 / GLM-5.x. In a multi-step tool loop some
+            // intermediate assistant turns carry tool_calls WITHOUT reasoning, so
+            // @ai-sdk/openai-compatible serializes them without a reasoning_content
+            // key → Z.ai rejects the whole request with HTTP 400 / code 1210
+            // "Invalid API parameter".
+            //
+            // We follow patterns seen in other mature clients (e.g. opencode) for
+            // robust GLM coding plan usage:
+            // - Conditional reasoning_content backfill (onlyIfMixed)
+            // - Force parallel_tool_calls: false (model still sometimes batches 2-5)
+            // - Drop null response_format (fragile with tools)
+            // - Clamp max_tokens, normalize tool-only assistant content shape
+            //
+            // See transformZaiThinkingBody for the full sanitization.
+            transformRequestBody: (body) => transformZaiThinkingBody(body),
+        });
+        return (modelId) => p(modelId);
+    }
+}
+//# sourceMappingURL=zai.strategy.js.map