muonroi-cli 1.8.4 → 1.8.5

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;

package/dist/src/providers/vision-backend.js

@@ -0,0 +1,258 @@
+import { getModelInfo, getVisionProxyRouting, MODELS, SWITCH_PROVIDER_ORDER } from "../models/registry.js";
+import { apiBaseFor } from "./endpoints.js";
+import { loadKeyForProvider } from "./keychain.js";
+const REQUEST_TIMEOUT_MS = 90_000;
+const DEFAULT_VISION_PROXY = {
+    default: { provider: "zai", model_id: "glm-4.6v-flash" },
+    ocr: { provider: "zai", model_id: "glm-4.6v-flash" },
+    design: { provider: "zai", model_id: "glm-5.2" },
+    fallback_chain: [
+        { provider: "xai", model_id: "grok-4.5" },
+        { provider: "zai", model_id: "glm-5.2" },
+    ],
+};
+const OCR_INTENT_RE = /\b(ocr|transcribe|read\s+(all\s+)?text|extract\s+text|text\s+in\s+(the\s+)?image|copy\s+text|what\s+(does|do)\s+it\s+say)\b/i;
+export function looksLikeOcrIntent(text) {
+    return OCR_INTENT_RE.test(text);
+}
+export function resolveVisionChain(kind) {
+    const routing = getVisionProxyRouting() ?? DEFAULT_VISION_PROXY;
+    const chain = [];
+    const primary = routing[kind] ?? routing.default;
+    if (primary)
+        chain.push(primary);
+    for (const slot of routing.fallback_chain ?? []) {
+        if (!chain.some((s) => s.provider === slot.provider && s.model_id === slot.model_id)) {
+            chain.push(slot);
+        }
+    }
+    if (chain.length === 0 && routing.default)
+        return [routing.default];
+    return chain;
+}
+async function slotHasAvailableKey(slot) {
+    try {
+        await loadKeyForProvider(slot.provider);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Vision-proxy chain filtered to providers that currently have API keys. */
+export async function resolveAvailableVisionChain(kind = "default") {
+    const available = [];
+    for (const slot of resolveVisionChain(kind)) {
+        if (await slotHasAvailableKey(slot))
+            available.push(slot);
+    }
+    return available;
+}
+export async function isVisionBackendAvailable(kind = "default") {
+    return (await resolveAvailableVisionChain(kind)).length > 0;
+}
+async function tryNativeVisionModel(modelId, source, excludeModelId) {
+    if (excludeModelId && modelId === excludeModelId)
+        return null;
+    const info = getModelInfo(modelId);
+    if (!info?.supportsVision)
+        return null;
+    const provider = info.provider;
+    const { isModelDisabled, isProviderDisabled } = await import("../utils/settings.js");
+    if (isProviderDisabled(provider) || isModelDisabled(modelId))
+        return null;
+    if (!(await slotHasAvailableKey({ provider, model_id: modelId })))
+        return null;
+    return { modelId, provider, source };
+}
+/**
+ * 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 async function findNativeVisionFallback(opts) {
+    const exclude = opts?.excludeModelId;
+    const seen = new Set();
+    for (const kind of ["default", "ocr", "design"]) {
+        for (const slot of resolveVisionChain(kind)) {
+            if (seen.has(slot.model_id))
+                continue;
+            seen.add(slot.model_id);
+            const hit = await tryNativeVisionModel(slot.model_id, "vision_proxy_slot", exclude);
+            if (hit)
+                return hit;
+        }
+    }
+    const visionByProvider = new Map();
+    for (const m of MODELS) {
+        if (!m.supportsVision || !m.provider)
+            continue;
+        const list = visionByProvider.get(m.provider) ?? [];
+        list.push(m);
+        visionByProvider.set(m.provider, list);
+    }
+    for (const provider of SWITCH_PROVIDER_ORDER) {
+        for (const m of visionByProvider.get(provider) ?? []) {
+            if (seen.has(m.id))
+                continue;
+            seen.add(m.id);
+            const hit = await tryNativeVisionModel(m.id, "catalog_vision", exclude);
+            if (hit)
+                return hit;
+        }
+    }
+    for (const m of MODELS) {
+        if (!m.supportsVision)
+            continue;
+        if (seen.has(m.id))
+            continue;
+        const hit = await tryNativeVisionModel(m.id, "catalog_vision", exclude);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+export async function collectVisionUnavailableReasons(kind = "default") {
+    const reasons = [];
+    for (const slot of resolveVisionChain(kind)) {
+        if (await slotHasAvailableKey(slot)) {
+            reasons.push(`${slot.model_id}@${slot.provider}: API key present but backend unreachable`);
+        }
+        else {
+            reasons.push(`${slot.model_id}@${slot.provider}: no API key`);
+        }
+    }
+    reasons.push("no other vision-capable catalog model has a configured API key");
+    return reasons;
+}
+export async function callVisionBackend(chain, content, signal, responseFormat) {
+    const failureReasons = [];
+    if (chain.length === 0) {
+        return { ok: false, reason: "no vision backend available — configure ZAI_API_KEY or XAI_API_KEY" };
+    }
+    for (const slot of chain) {
+        const provider = slot.provider;
+        let apiKey;
+        try {
+            apiKey = await loadKeyForProvider(provider);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            failureReasons.push(`${slot.model_id}@${provider}: no API key (${msg})`);
+            continue;
+        }
+        const base = apiBaseFor(provider);
+        const result = await callVisionModelAt(base, slot.model_id, content, apiKey, signal, responseFormat);
+        if (result.ok) {
+            return { ok: true, text: result.text, model: slot.model_id, provider };
+        }
+        failureReasons.push(`${slot.model_id}@${provider}: ${result.reason}`);
+        console.warn(`[vision-backend] ${slot.model_id}@${provider} failed (${result.reason}), trying next...`);
+    }
+    return { ok: false, reason: failureReasons.join(" | ") || "no vision backend configured" };
+}
+async function callVisionModelAt(baseURL, 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 });
+    }
+    const url = `${baseURL.replace(/\/$/, "")}/chat/completions`;
+    let res;
+    try {
+        res = await fetch(url, {
+            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)
+            return { ok: false, reason: `timeout after ${REQUEST_TIMEOUT_MS}ms` };
+        if (signal?.aborted)
+            throw err;
+        return { ok: false, reason: `network error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    clearTimeout(timeout);
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        return { ok: false, reason: `HTTP ${res.status} ${errText.slice(0, 200)}` };
+    }
+    const data = (await res.json().catch(() => null));
+    const text = data?.choices?.[0]?.message?.content;
+    if (!text)
+        return { ok: false, reason: "empty response body" };
+    return { ok: true, text };
+}
+/** Ask the vision model to write as direct sight for the primary (text-only) agent. */
+export function wrapAnalyzerInstructions(userPrompt, kind) {
+    const style = kind === "design"
+        ? "Output ONLY valid JSON matching the requested schema. No markdown fences."
+        : "Write in clear markdown. Use first-person present tense ('I see…', 'The screenshot shows…').";
+    return [
+        userPrompt,
+        "",
+        "IMPORTANT — output style for the primary coding agent:",
+        "- Write as a DIRECT visual observation. The reader will treat your words as its own native sight.",
+        "- Do NOT mention vision proxy, backend models, or that you are a separate model.",
+        `- ${style}`,
+        "- If something is illegible, cropped, or ambiguous, say exactly what is unclear and what would help (closer crop, higher resolution, different angle).",
+    ].join("\n");
+}
+/**
+ * Envelope injected into text-only model context — reads as native vision, not third-party analysis.
+ */
+export function formatNativeVisionObservation(observation, opts) {
+    const subject = opts.imageCount > 1 ? `these ${opts.imageCount} images` : "this image";
+    const cacheHint = opts.cachedIds && opts.cachedIds.length > 0
+        ? `- Cached as ${opts.cachedIds.join(", ")} — use ask_vision_proxy with a specific question to inspect a detail`
+        : "";
+    return [
+        "<vision-observation>",
+        `You are viewing ${subject}. Treat everything below as your direct visual observation — reason and respond as if you saw it yourself.`,
+        "",
+        observation.trim(),
+        "",
+        "If any detail is unclear, cropped, or you need another angle:",
+        "- ask_vision_proxy with a precise question (region, color, text, UI element)",
+        "- analyze_image on the file path to re-inspect or compare a fresh screenshot",
+        "- ask the user to share another image or clarify what to focus on",
+        cacheHint,
+        "</vision-observation>",
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
+}
+export function formatNativeVisionUnavailable(imageCount, reasons, cachedIds) {
+    const types = imageCount > 1 ? `${imageCount} images` : "1 image";
+    const cacheHint = cachedIds && cachedIds.length > 0 ? `Cached IDs: ${cachedIds.join(", ")} — try ask_vision_proxy anyway.` : "";
+    const detail = reasons.length > 0 ? reasons.join(" | ") : "vision backend unreachable";
+    return [
+        '<vision-observation status="unavailable">',
+        `${types} could not be analyzed (${detail}).`,
+        "Do NOT guess what the image contains.",
+        "Setup: configure ZAI_API_KEY or XAI_API_KEY for vision proxy, or switch to a vision-capable default model.",
+        "- Retry with analyze_image and the file path once a vision key is configured",
+        "- Use ask_vision_proxy if a cached image exists",
+        "- Ask the user to re-share the screenshot or describe what you need to see",
+        cacheHint,
+        "</vision-observation>",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+//# sourceMappingURL=vision-backend.js.map

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

@@ -1,23 +1,36 @@
 /**
  * Vision proxy layer for text-only models (e.g. DeepSeek V4).
  *
- * When the active model does not support vision, image parts in the message
- * are extracted, sent to a cheap vision model on SiliconFlow
- * (Qwen/Qwen2.5-VL-32B-Instruct @ $0.27/M tokens), and replaced with
- * structured text descriptions before the message reaches the primary model.
+ * Image parts in messages are sent to the catalog-configured vision backend
+ * (default: Z.ai glm-4.6v-flash) and replaced with native-sight observations
+ * so the primary model reasons as if it saw the image directly.
  */
 import type { ModelMessage } from "ai";
+import { type NativeVisionFallback, type VisionTaskKind } from "./vision-backend.js";
 export interface VisionProxyResult {
     messages: ModelMessage[];
     proxied: boolean;
     imageCount: number;
 }
-/**
- * Returns true when the model cannot handle image content natively.
- */
 export declare function needsVisionProxy(modelId: string): boolean;
+export type ImageHandlingPlan = {
+    strategy: "proxy";
+} | {
+    strategy: "native_model";
+    fallback: NativeVisionFallback;
+} | {
+    strategy: "unavailable";
+    notice: string;
+};
 /**
- * Process messages through the vision proxy.
- * Only messages with image parts are modified; text-only messages pass through.
+ * Decide how to handle images when the active model is text-only:
+ * proxy backend, switch to a native vision model, or surface unavailable.
  */
+export declare function planImageHandlingForTextOnlyModel(opts: {
+    primaryModelId: string;
+    imageCount: number;
+    kind?: VisionTaskKind;
+}): Promise<ImageHandlingPlan>;
+/** True when proxy backend or a native vision model can handle images for this text-only model. */
+export declare function canHandleImagesForTextOnlyModel(modelId: string): Promise<boolean>;
 export declare function proxyVision(messages: ModelMessage[], modelId: string, signal?: AbortSignal): Promise<VisionProxyResult>;