muonroi-cli 1.8.3 → 1.8.5

package/dist/src/providers/runtime.js

@@ -1,8 +1,24 @@
 import { createHash } from "node:crypto";
 import { getModelInfo } from "../models/registry.js";
+import { logger } from "../utils/logger.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.
+ * resolveModelRuntime consults this to auto-correct a factory/model provider
+ * mismatch: when a caller reuses provider A's factory to run a model that
+ * belongs to provider B (a real hazard in sub-task paths like compaction that
+ * inherit the parent session's factory), we substitute B's real factory if one
+ * was built this session. 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 transparently 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();
+}
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -10,15 +26,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 +55,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;
@@ -68,8 +84,8 @@ export async function createProviderFactoryAsync(id, opts) {
 }
 export function resolveModelRuntime(factory, 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);
@@ -78,6 +94,32 @@ export function resolveModelRuntime(factory, modelId) {
     if (!providerId && !mockGlobals.__muonroiMockModel) {
         throw new Error(`Model "${modelId}" not found in catalog — cannot determine provider.`);
     }
+    // Factory/model provider guard (Layer 2). A caller that reuses one provider's
+    // factory to run a model from another provider (e.g. compaction inheriting the
+    // parent session's native factory for a gateway-routed model) would otherwise
+    // POST to the wrong endpoint. If the passed factory is stamped for a different
+    // provider AND we built the correct one this session, substitute it so the
+    // request lands on the right backend; otherwise keep going (Part 3's wire-id
+    // normalization keeps it valid) but log the mismatch so it is never silent.
+    let effectiveFactory = factory;
+    if (providerId && factory.providerId && factory.providerId !== providerId) {
+        const correct = providerFactoryRegistry.get(providerId);
+        if (correct) {
+            effectiveFactory = correct;
+            logger.debug("orchestrator", "Redirected model to its own provider factory", {
+                modelId: canonicalId,
+                modelProvider: providerId,
+                factoryProvider: factory.providerId,
+            });
+        }
+        else {
+            logger.warn("orchestrator", "Factory/model provider mismatch; no factory for model's provider", {
+                modelId: canonicalId,
+                modelProvider: providerId,
+                factoryProvider: factory.providerId,
+            });
+        }
+    }
     const userEffort = getReasoningEffortForModel(modelId);
     const mockModel = mockGlobals.__muonroiMockModel;
     // Determine the language model + unsupportedParams + provider-level defaults.
@@ -107,12 +149,12 @@ export function resolveModelRuntime(factory, modelId) {
     else {
         const strategy = getProviderStrategy(providerId);
         resolved = strategy.resolve({
-            factory,
+            factory: effectiveFactory,
             modelId: canonicalId,
             modelInfo,
             reasoningEffort: userEffort,
         });
-        providerLevelDefaults = factory.defaultProviderOptions;
+        providerLevelDefaults = effectiveFactory.defaultProviderOptions;
     }
     // Merge provider-level defaults from the factory (e.g. OAuth backends inject
     // `instructions` + `store: false` for the ChatGPT Codex API). This keeps
@@ -229,6 +271,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 +303,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 {};