muonroi-cli 1.8.4 → 1.9.0

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,209 @@ 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 {
+                        const parsed = JSON.parse(trimmed);
+                        // Tool arguments MUST be a JSON object. grok-composer (and some other
+                        // models) occasionally emit a bare string / number / array / null —
+                        // valid JSON but the wrong shape — which xAI rejects with 400
+                        // "expected JSON object for tool arguments" (a non-transient error
+                        // that wedges the retry loop). Normalize any non-object to {}.
+                        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                            repaired = "{}";
+                        }
+                    }
+                    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/xai.strategy.js

@@ -7,6 +7,7 @@ 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 { sanitizeToolCallArguments, splitParallelToolCalls } from "./thinking-mode.js";
 export class XAIStrategy extends BaseProviderStrategy {
     id = "xai";
     capabilities = getProviderCapabilities("xai");
@@ -22,6 +23,32 @@ export class XAIStrategy extends BaseProviderStrategy {
             baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.xai,
             apiKey: opts.apiKey ?? (opts.headers ? "oauth" : undefined),
             ...(opts.headers ? { headers: opts.headers } : {}),
+            // grok-composer (Cursor Composer via xAI) emits BATCHES of parallel
+            // tool_calls per assistant turn, and some carry empty/truncated
+            // `arguments` strings. On the next multi-step request xAI rejects the
+            // replayed history with 400 `invalid-argument: expected JSON object for
+            // tool arguments` — a NON-transient error, so the bounded stream-retry
+            // re-sends the same malformed history and the turn wedges (observed live
+            // 2026-07-14, run mrkoeezk9a29: /ideal sprint impl made one tool-call
+            // response then never progressed, 0 files, across every path). Mirror the
+            // opencode-go/zai fix: split multi-tool-call assistant turns into
+            // sequential single-call turns and repair empty/truncated tool arguments
+            // to `{}` before they reach the upstream. Both helpers are no-ops unless
+            // the failing pattern is present, so healthy requests are untouched.
+            transformRequestBody: (body) => {
+                const out = { ...body };
+                if (Array.isArray(out.messages)) {
+                    out.messages = splitParallelToolCalls(out.messages);
+                    out.messages = sanitizeToolCallArguments(out.messages);
+                }
+                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) => p(modelId);
     }

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

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

@@ -59,10 +59,9 @@ export interface ProviderRequest {
 export type ProviderStream = AsyncGenerator<StreamChunk, void, unknown>;
 /**
  * Supported provider identifiers.
- * 'google' maps to Gemini/Agy via @ai-sdk/google; 'deepseek' and 'siliconflow'
- * share the OpenAI-compatible adapter with different baseURLs.
+ * 'deepseek' shares the OpenAI-compatible adapter with a custom baseURL.
  */
-export type ProviderId = "anthropic" | "openai" | "google" | "deepseek" | "siliconflow" | "xai" | "ollama";
+export type ProviderId = "anthropic" | "openai" | "deepseek" | "xai" | "ollama" | "zai" | "opencode-go";
 /**
  * Single source of truth for the canonical ordering of all provider IDs.
  * Phase 12.2-G5: every site that needs to iterate providers (config screens,
@@ -70,7 +69,7 @@ export type ProviderId = "anthropic" | "openai" | "google" | "deepseek" | "silic
  * this constant instead of duplicating the literal array. Filter/slice
  * variations are allowed (e.g. `ALL_PROVIDER_IDS.filter(p => p !== "xai")`).
  */
-export declare const ALL_PROVIDER_IDS: readonly ["anthropic", "openai", "google", "deepseek", "siliconflow", "xai", "ollama"];
+export declare const ALL_PROVIDER_IDS: readonly ["anthropic", "openai", "deepseek", "xai", "ollama", "zai", "opencode-go"];
 /** Convenience iterator over the canonical provider list. */
 export declare function iterProviders(): readonly ProviderId[];
 /**
@@ -79,7 +78,7 @@ export declare function iterProviders(): readonly ProviderId[];
 export interface ProviderConfig {
     /** BYOK API key. Ollama may be keyless; defaults to env OLLAMA_API_KEY when present. */
     apiKey?: string;
-    /** Base URL override for OpenAI-compatible providers (deepseek/siliconflow) + ollama VPS. */
+    /** Base URL override for OpenAI-compatible providers (deepseek) + ollama VPS. */
     baseURL?: string;
     /** AI model identifier, e.g. "claude-3-5-haiku-latest". */
     model: string;
@@ -91,7 +90,7 @@ export interface ProviderConfig {
      *
      * Adding OAuth for a new provider:
      *   1. Add an entry to `providers/auth/registry.ts` (login flow + token store).
-     *   2. Ensure that provider's adapter honors `oauthHeaders` (see openai.ts/anthropic.ts/gemini.ts).
+     *   2. Ensure that provider's adapter honors `oauthHeaders` (see openai.ts/anthropic.ts).
      *   3. Done — `createAdapterAsync` dispatches via the registry; no other code edits required.
      */
     oauthHeaders?: Record<string, string>;

package/dist/src/providers/types.js

@@ -18,11 +18,11 @@
 export const ALL_PROVIDER_IDS = [
     "anthropic",
     "openai",
-    "google",
     "deepseek",
-    "siliconflow",
     "xai",
     "ollama",
+    "zai",
+    "opencode-go",
 ];
 /** Convenience iterator over the canonical provider list. */
 export function iterProviders() {

package/dist/src/providers/vision-backend.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Catalog-driven vision proxy backend — replaces hardcoded SiliconFlow Qwen VL.
+ * Used by vision-proxy.ts (message path) and mcp-vision-bridge.ts (tool path).
+ */
+import type { CatalogVisionProxySlot } from "../models/catalog-client.js";
+import type { ProviderId } from "./types.js";
+export type VisionTaskKind = "default" | "ocr" | "design";
+export declare function looksLikeOcrIntent(text: string): boolean;
+export declare function resolveVisionChain(kind: VisionTaskKind): CatalogVisionProxySlot[];
+/** Vision-proxy chain filtered to providers that currently have API keys. */
+export declare function resolveAvailableVisionChain(kind?: VisionTaskKind): Promise<CatalogVisionProxySlot[]>;
+export declare function isVisionBackendAvailable(kind?: VisionTaskKind): Promise<boolean>;
+export interface NativeVisionFallback {
+    modelId: string;
+    provider: ProviderId;
+    source: "vision_proxy_slot" | "catalog_vision";
+}
+/**
+ * When vision-proxy backends have no keys, pick a catalog vision model (with key)
+ * so images can be sent natively instead of failing on a text-only primary.
+ */
+export declare function findNativeVisionFallback(opts?: {
+    excludeModelId?: string;
+}): Promise<NativeVisionFallback | null>;
+export declare function collectVisionUnavailableReasons(kind?: VisionTaskKind): Promise<string[]>;
+export type VisionCallResult = {
+    ok: true;
+    text: string;
+    model: string;
+    provider: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function callVisionBackend(chain: CatalogVisionProxySlot[], content: Array<Record<string, unknown>>, signal?: AbortSignal, responseFormat?: {
+    type: "json_object";
+}): Promise<VisionCallResult>;
+/** Ask the vision model to write as direct sight for the primary (text-only) agent. */
+export declare function wrapAnalyzerInstructions(userPrompt: string, kind: VisionTaskKind): string;
+/**
+ * Envelope injected into text-only model context — reads as native vision, not third-party analysis.
+ */
+export declare function formatNativeVisionObservation(observation: string, opts: {
+    imageCount: number;
+    cachedIds?: string[];
+}): string;
+export declare function formatNativeVisionUnavailable(imageCount: number, reasons: string[], cachedIds?: string[]): string;