muonroi-cli 1.8.4 → 1.8.5

package/dist/src/providers/mcp-vision-bridge.js

@@ -12,16 +12,8 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
-import { apiBaseFor } from "./endpoints.js";
-import { loadKeyForProvider } from "./keychain.js";
+import { callVisionBackend, formatNativeVisionObservation, formatNativeVisionUnavailable, looksLikeOcrIntent, resolveAvailableVisionChain, wrapAnalyzerInstructions, } from "./vision-backend.js";
 import { needsVisionProxy } from "./vision-proxy.js";
-const VISION_MODELS = [
-    "Qwen/Qwen3-VL-8B-Instruct",
-    "Qwen/Qwen3-VL-30B-A3B-Instruct",
-    "Qwen/Qwen3-VL-32B-Instruct",
-];
-const SILICONFLOW_BASE = apiBaseFor("siliconflow");
-const REQUEST_TIMEOUT_MS = 90_000;
 const IMAGE_CACHE_MAX = 20;
 const IMAGE_CACHE_TTL_MS = 15 * 60 * 1000; // 15 minutes
 /**
@@ -174,8 +166,8 @@ export async function bridgeMcpToolResult(toolName, toolOutput, modelId, signal,
     }
     // Detect context for better analysis prompt
     const context = detectImageContext(toolName, toolOutput);
-    const description = await analyzeImages(images, context, signal);
-    if (!description) {
+    const rawObservation = await analyzeImages(images, context, signal);
+    if (!rawObservation) {
         // Even when the vision proxy fails (no API key / network error), we MUST
         // still strip the base64 payload from the tool output. Otherwise a single
         // Playwright screenshot (~1.5MB of base64) lands in conversation history
@@ -187,15 +179,21 @@ export async function bridgeMcpToolResult(toolName, toolOutput, modelId, signal,
             proxied: true,
         };
     }
-    const cachedIds = addToCache(images.map((img) => ({ ...img, source: baseName || toolName })), description, `${baseName} result`);
+    const cachedIds = addToCache(images.map((img) => ({ ...img, source: baseName || toolName })), rawObservation, `${baseName} result`);
     const cleanOutput = stripBase64FromOutput(toolOutput);
-    const cacheHint = `\n[Cached as ${cachedIds.join(", ")} — use ask_vision_proxy for follow-up questions]`;
-    const fullDescription = `${description}${cacheHint}`;
+    const fullDescription = formatNativeVisionObservation(rawObservation, {
+        imageCount: images.length,
+        cachedIds,
+    });
     const enhanced = typeof cleanOutput === "string"
         ? `${cleanOutput}\n\n${fullDescription}`
-        : { ...cleanOutput, _visionDescription: description, _cachedImageIds: cachedIds };
+        : {
+            ...cleanOutput,
+            _visionDescription: fullDescription,
+            _cachedImageIds: cachedIds,
+        };
     recordBridgedDescription(toolCallId, fullDescription);
-    return { output: enhanced, proxied: true, description, cachedImageIds: cachedIds };
+    return { output: enhanced, proxied: true, description: fullDescription, cachedImageIds: cachedIds };
 }
 /**
  * Proactively analyze an image from a file path, URL, or raw base64.
@@ -246,12 +244,13 @@ export async function analyzeImageFromSource(source, question, cwd, signal) {
     }
     const context = question ? { type: "user-query", hint: question } : { type: "generic" };
     const prompt = question ? buildFollowUpPrompt(question, images.length) : undefined;
-    const description = await analyzeImages(images, context, signal, prompt);
-    if (!description) {
-        return "Vision proxy could not analyze the image. Check SILICONFLOW_API_KEY configuration.";
+    const rawObservation = await analyzeImages(images, context, signal, prompt);
+    if (!rawObservation) {
+        const { collectVisionUnavailableReasons } = await import("./vision-backend.js");
+        return formatNativeVisionUnavailable(1, await collectVisionUnavailableReasons());
     }
-    const cachedIds = addToCache(images, description, source);
-    return `${description}\n[Cached as ${cachedIds.join(", ")} — use ask_vision_proxy for follow-up questions]`;
+    const cachedIds = addToCache(images, rawObservation, source);
+    return formatNativeVisionObservation(rawObservation, { imageCount: images.length, cachedIds });
 }
 /**
  * Ask a follow-up question about a previously cached image,
@@ -278,17 +277,10 @@ export async function askVisionProxy(question, imageIdOrPath, cwd, signal) {
         }
         return `No matching image. Available:\n${cached.map((c) => `- ${c.id}: ${c.label} (${c.age})`).join("\n")}\n\nSpecify image_id, or provide a file_path to analyze a new image.`;
     }
-    let apiKey;
-    try {
-        apiKey = await loadKeyForProvider("siliconflow");
-    }
-    catch {
-        return "Vision proxy unavailable — SILICONFLOW_API_KEY not configured.";
-    }
     const visionContent = [];
     visionContent.push({
         type: "text",
-        text: buildFollowUpPrompt(question, targets.length),
+        text: wrapAnalyzerInstructions(buildFollowUpPrompt(question, targets.length), looksLikeOcrIntent(question) ? "ocr" : "default"),
     });
     for (const img of targets) {
         visionContent.push({
@@ -299,19 +291,15 @@ export async function askVisionProxy(question, imageIdOrPath, cwd, signal) {
             },
         });
     }
-    for (const model of VISION_MODELS) {
-        try {
-            const result = await callVisionModel(model, visionContent, apiKey, signal);
-            if (result) {
-                return `[Vision Proxy Answer — via ${model}]\n${result}\n[/Vision Proxy Answer]`;
-            }
-        }
-        catch (err) {
-            if (signal?.aborted)
-                throw err;
-        }
+    const kind = looksLikeOcrIntent(question) ? "ocr" : "default";
+    const result = await callVisionBackend(await resolveAvailableVisionChain(kind), visionContent, signal);
+    if (result.ok) {
+        return formatNativeVisionObservation(result.text, {
+            imageCount: targets.length,
+            cachedIds: targets.map((t) => t.id),
+        });
     }
-    return "Vision proxy failed. Try again or describe what you need help with.";
+    return formatNativeVisionUnavailable(targets.length, [result.reason]);
 }
 /**
  * System prompt guidance for text-only models — UNIVERSAL, not Playwright-specific.
@@ -320,32 +308,27 @@ export function getVisionGuidanceForTextOnly(modelId) {
     if (!needsVisionProxy(modelId))
         return "";
     return `
-VISION PROXY (text-only model):
-You cannot see images directly. You have vision proxy tools to work with ANY image:
+VISION (extended capability):
+You have full visual understanding via auto-injected <vision-observation> blocks and vision tools.
+Treat every <vision-observation> as YOUR direct sight — respond naturally as if you saw the image yourself.
 
-TOOLS:
-- analyze_image: Proactively analyze an image from a file path, URL, or base64. Use this FIRST when you encounter or need to work with an image.
-- ask_vision_proxy: Ask a specific follow-up question about any cached image (or provide a file path for a new image).
-- list_vision_cache: See all cached images available for querying.
+TOOLS (when you need a closer look or a new image):
+- analyze_image: Inspect an image file path, data URI, or base64. Use when you encounter a new image or need a fresh screenshot analyzed.
+- ask_vision_proxy: Ask a follow-up about a cached image (by ID) or a file path — zoom in on a region, read text, compare colors.
+- list_vision_cache: List cached image IDs available for follow-up questions.
 
-WHEN TO USE (be PROACTIVE, not passive):
-- User mentions an image file → analyze_image immediately
-- User pastes or references a screenshot → it's auto-analyzed, use ask_vision_proxy for details
-- Working with UI/web pages → prefer browser_snapshot (text-based), use screenshot + ask_vision_proxy when visual details matter
-- Reviewing design mockups, diagrams, charts → analyze_image the file
-- Debugging visual issues (CSS, layout, colors) → take screenshot, then ask_vision_proxy specific questions
-- Comparing before/after → analyze both images, ask about differences
-- Reading text from images (OCR) → analyze_image with a question like "transcribe all text"
-- Any file with image extension (.png, .jpg, .gif, .webp, .svg, etc.) → analyze_image
+WHEN TO ACT:
+- User mentions an image → analyze_image immediately (do not guess)
+- Tool results include <vision-observation> → use that as your sight; ask_vision_proxy if any detail is unclear
+- UI debugging → screenshot + ask_vision_proxy for specific elements
+- OCR / transcribe → analyze_image with question "transcribe all visible text"
 
-WORKFLOW:
-1. Encounter image → analyze_image (or it's auto-analyzed from tool results)
-2. Need more detail → ask_vision_proxy with specific question
-3. Need to verify changes → take new screenshot/analyze new image → compare
+IF STILL UNCLEAR after an observation:
+1. ask_vision_proxy with a precise question about the unclear region or text
+2. analyze_image again on a new or higher-resolution file
+3. Ask the user to share another screenshot or clarify what to focus on
 
-Images are cached (up to ${IMAGE_CACHE_MAX}, ${IMAGE_CACHE_TTL_MS / 60000}min TTL). You can reference them by ID for follow-ups.
-
-IMPORTANT: Do NOT guess what an image contains. Always use the proxy to get accurate information.
+Never invent visual details. Cached images: up to ${IMAGE_CACHE_MAX}, ${IMAGE_CACHE_TTL_MS / 60000}min TTL.
 `;
 }
 // Keep backward compat export
@@ -380,17 +363,11 @@ async function analyzeImages(images, context, signal, customPrompt) {
     const svgFast = trySvgFastPath(images, context);
     if (svgFast)
         return svgFast;
-    let apiKey;
-    try {
-        apiKey = await loadKeyForProvider("siliconflow");
-    }
-    catch {
-        return null;
-    }
+    const kind = context.type === "design" ? "design" : customPrompt && looksLikeOcrIntent(customPrompt) ? "ocr" : "default";
     const visionContent = [];
     visionContent.push({
         type: "text",
-        text: customPrompt ?? buildContextualPrompt(images.length, context),
+        text: wrapAnalyzerInstructions(customPrompt ?? buildContextualPrompt(images.length, context), kind),
     });
     for (const img of images) {
         visionContent.push({
@@ -401,22 +378,10 @@ async function analyzeImages(images, context, signal, customPrompt) {
             },
         });
     }
-    // Force JSON output for the design contract. Markdown narrative is fine for
-    // debug-style contexts (terminal, code) where the human reads the result,
-    // but design output is consumed machine-to-machine.
     const responseFormat = context.type === "design" ? { type: "json_object" } : undefined;
-    for (const model of VISION_MODELS) {
-        try {
-            const result = await callVisionModel(model, visionContent, apiKey, signal, responseFormat);
-            if (result) {
-                return formatBridgeResult(result, images.length, model, context.type);
-            }
-        }
-        catch (err) {
-            if (signal?.aborted)
-                throw err;
-        }
-    }
+    const result = await callVisionBackend(await resolveAvailableVisionChain(kind), visionContent, signal, responseFormat);
+    if (result.ok)
+        return result.text;
     return null;
 }
 function trySvgFastPath(images, context) {
@@ -437,11 +402,10 @@ function trySvgFastPath(images, context) {
         return svg.length > 32_000 ? `${svg.slice(0, 32_000)}\n<!-- truncated -->` : svg;
     })
         .join("\n\n");
-    const header = `[Vision Bridge — ${images.length} SVG source(s) passed through (${context.type}, fast-path, no vision call)]`;
-    const guidance = context.type === "design"
-        ? `\nThe raw SVG below IS the layout contract. Coordinates and colors are exact. Map <rect>/<text>/<g> nodes to the schema:\n${UI_LAYOUT_SCHEMA_HINT}\n`
-        : "\nThe raw SVG below is vector text — read element attributes (x, y, width, fill, text content) directly.\n";
-    return `\n${header}${guidance}\n\`\`\`svg\n${decoded}\n\`\`\`\n[/Vision Bridge]\n`;
+    const observation = context.type === "design"
+        ? `I see ${images.length} SVG source(s). Vector markup is exact — map nodes to:\n${UI_LAYOUT_SCHEMA_HINT}\n\n\`\`\`svg\n${decoded}\n\`\`\``
+        : `I see ${images.length} SVG source(s). Vector markup:\n\n\`\`\`svg\n${decoded}\n\`\`\``;
+    return observation;
 }
 function buildContextualPrompt(imageCount, context) {
     const plural = imageCount > 1 ? `${imageCount} images` : "the image";
@@ -799,63 +763,9 @@ function walkAndStrip(obj) {
     }
 }
 function wrapWithFallback(output, imageCount) {
-    const notice = `\n[Vision Bridge — ${imageCount} image(s) could not be analyzed. Use analyze_image or ask_vision_proxy with a file path to retry.]\n`;
+    const notice = formatNativeVisionUnavailable(imageCount, ["auto-analysis failed"]);
     if (typeof output === "string")
         return `${output}\n${notice}`;
     return { ...output, _visionNotice: notice };
 }
-async function callVisionModel(model, content, apiKey, signal, responseFormat) {
-    const controller = new AbortController();
-    let timedOut = false;
-    const timeout = setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-    }, REQUEST_TIMEOUT_MS);
-    if (signal) {
-        signal.addEventListener("abort", () => controller.abort(), { once: true });
-    }
-    let res;
-    try {
-        res = await fetch(`${SILICONFLOW_BASE}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${apiKey}`,
-            },
-            body: JSON.stringify({
-                model,
-                messages: [{ role: "user", content }],
-                max_tokens: 3072,
-                temperature: 0.1,
-                ...(responseFormat ? { response_format: responseFormat } : {}),
-            }),
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        clearTimeout(timeout);
-        if (timedOut) {
-            console.warn(`[vision-bridge] ${model} timed out after ${REQUEST_TIMEOUT_MS}ms`);
-            return null;
-        }
-        if (signal?.aborted)
-            throw err;
-        console.warn(`[vision-bridge] ${model} network error: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-    clearTimeout(timeout);
-    if (!res.ok) {
-        const errText = await res.text().catch(() => "");
-        console.warn(`[vision-bridge] ${model} HTTP ${res.status}: ${errText.slice(0, 200)}`);
-        return null;
-    }
-    const data = (await res.json().catch(() => null));
-    return data?.choices?.[0]?.message?.content ?? null;
-}
-function formatBridgeResult(description, imageCount, model, contextType) {
-    const header = imageCount > 1
-        ? `[Vision Bridge — ${imageCount} images analyzed (${contextType}) via ${model}]`
-        : `[Vision Bridge — image analyzed (${contextType}) via ${model}]`;
-    return `\n${header}\n${description}\n[/Vision Bridge]\n`;
-}
 //# sourceMappingURL=mcp-vision-bridge.js.map

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,15 @@ 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 so a
+     * caller that blindly reuses one provider's factory with a model from a
+     * DIFFERENT provider can be detected and auto-corrected in resolveModelRuntime
+     * (see the factory registry below) — otherwise the request would hit the wrong
+     * endpoint (e.g. a gateway-routed model POSTed straight to a native API,
+     * bypassing the configured gateway).
+     */
+    providerId?: ProviderId;
 };
 export interface ProviderFactoryResult {
     id: ProviderId;
@@ -19,6 +28,8 @@ 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;
 /**
  * Phase 12.2-G4: thin dispatcher delegating to the provider strategy registry.
  * Each provider's SDK wiring + `factory.responses` + `defaultProviderOptions`
@@ -34,8 +45,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.
  */
@@ -87,5 +96,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

@@ -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;