muonroi-cli 1.8.4 → 1.9.0

package/dist/src/providers/keychain.js

@@ -1,49 +1,30 @@
 /**
  * src/providers/keychain.ts
  *
- * Per-provider keychain loader with env-var fallback.
- * Extends the Phase 0 loadAnthropicKey pattern to all 6 providers.
- * PROV-02 / PROV-03 requirements.
+ * Per-provider key store. Backed by the env-store (`.env` file + process.env +
+ * Windows registry mirror) — the OS keychain (keytar) has been removed.
  *
- * Priority: OS keychain (keytar) > environment variable > settings.json > ProviderKeyMissingError.
+ * Source of truth: `process.env[ENV_BY_PROVIDER[provider]]`. Writes go through
+ * the env-store; reads come straight from process.env.
  * Exception: ollama is keyless by default.
  */
 import { redactor } from "../utils/redactor.js";
+import { clearEnvVar, persistEnvVar } from "./env-store.js";
 import { ALL_PROVIDER_IDS } from "./types.js";
 function normalizeKeychainProvider(p) {
     const lower = p.toLowerCase();
-    if (lower === "agy")
-        return "google"; // agy alias for google provider
     if (ALL_PROVIDER_IDS.includes(lower))
         return lower;
     return null;
 }
-const SETTINGS_KEY_MAP = {
-    anthropic: "anthropic",
-    openai: "openai",
-    google: "google",
-    deepseek: "deepseek",
-    siliconflow: "siliconflow",
-    xai: "xai",
-};
-const KEYCHAIN_SERVICE = "muonroi-cli";
-const ACCOUNT_BY_PROVIDER = {
-    anthropic: "anthropic",
-    openai: "openai",
-    google: "google",
-    deepseek: "deepseek",
-    siliconflow: "siliconflow",
-    xai: "xai",
-    ollama: "ollama",
-};
-const ENV_BY_PROVIDER = {
+export const ENV_BY_PROVIDER = {
     anthropic: "ANTHROPIC_API_KEY",
     openai: "OPENAI_API_KEY",
-    google: "GOOGLE_API_KEY",
     deepseek: "DEEPSEEK_API_KEY",
-    siliconflow: "SILICONFLOW_API_KEY",
     xai: "XAI_API_KEY",
     ollama: "OLLAMA_API_KEY",
+    zai: "ZAI_API_KEY",
+    "opencode-go": "OPENCODE_GO_API_KEY",
 };
 /**
  * Thrown when no API key can be found for a provider.
@@ -56,147 +37,83 @@ export class ProviderKeyMissingError extends Error {
         this.name = "ProviderKeyMissingError";
     }
 }
-async function loadKeytar() {
-    try {
-        return (await import("keytar"));
-    }
-    catch {
-        return null;
-    }
-}
 /**
- * Providers that store an API key in the OS keychain.
- * Phase 12.2-G5: derived from `ALL_PROVIDER_IDS` by excluding ollama
- * (keyless local server). Preserves the original ordering.
+ * Providers that store an API key (all except keyless ollama). Derived from
+ * `ALL_PROVIDER_IDS`; preserves the original ordering.
  */
 export const KEYCHAIN_PROVIDER_IDS = ALL_PROVIDER_IDS.filter((p) => p !== "ollama");
 /**
- * Store a provider API key in the OS keychain. Returns true on success.
- * Falls back to false (silent) if keytar is unavailable on this platform.
+ * Store a provider API key in the OS environment (via the env-store: `.env`
+ * file + process.env + Windows registry mirror). Returns true on success.
  */
 export async function setKeyForProvider(provider, key) {
     const norm = normalizeKeychainProvider(provider) ?? provider;
     if (!key || key.length < 20) {
         throw new Error(`Key for '${provider}' is too short (< 20 chars).`);
     }
-    const kt = await loadKeytar();
-    if (!kt?.setPassword)
-        return false;
-    redactor.enrollSecret(key);
+    persistEnvVar(ENV_BY_PROVIDER[norm], key);
+    // One auth mode per provider (OAuth XOR API key): setting an API key logs out
+    // any OAuth session for this provider so the two can never coexist.
     try {
-        await kt.setPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_PROVIDER[norm], key);
-        return true;
+        const { listOAuthProviderIds } = await import("./auth/registry.js");
+        if ((await listOAuthProviderIds()).includes(norm)) {
+            const { deleteTokens } = await import("./auth/token-store.js");
+            await deleteTokens(norm);
+        }
     }
     catch (err) {
-        // Runtime backend failure is common on Linux when libsecret / secret service
-        // (gnome-keyring, kwallet/ksecretd, etc.) is not installed, the collection is
-        // locked, or no D-Bus session/keyring is active for this user.
-        // The caller (e.g. keys import-bw / keys set) will print the friendly message.
-        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
-            console.error(`[keychain] setPassword backend error for ${provider}:`, err?.message || err);
+        // Best-effort: the key is already persisted; failing to clear tokens is
+        // non-fatal (resolution still prefers the freshly-set key path only if no
+        // token — but we log so a lingering token is diagnosable).
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[keychain] failed to clear OAuth for ${norm}: ${err instanceof Error ? err.message : String(err)}`);
         }
-        return false;
     }
+    return true;
 }
 /**
- * Delete a stored key. Returns true if a key was deleted, false if none was
- * present or keytar is unavailable.
+ * Delete a stored key from the env-store. Returns true if a key was present.
  */
 export async function deleteKeyForProvider(provider) {
     const norm = normalizeKeychainProvider(provider) ?? provider;
-    const kt = await loadKeytar();
-    if (!kt?.deletePassword)
-        return false;
-    try {
-        return await kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_PROVIDER[norm]);
-    }
-    catch (err) {
-        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
-            console.error(`[keychain] deletePassword backend error for ${provider}:`, err?.message || err);
-        }
-        return false;
-    }
+    const had = !!process.env[ENV_BY_PROVIDER[norm]];
+    clearEnvVar(ENV_BY_PROVIDER[norm]);
+    return had;
 }
 /**
- * List provider IDs that currently have a key stored in the keychain.
- * Empty array if keytar is unavailable.
+ * List provider IDs that currently have a key set in the environment.
  */
 export async function listStoredProviders() {
-    const kt = await loadKeytar();
-    if (!kt?.findCredentials)
-        return [];
-    try {
-        const creds = await kt.findCredentials(KEYCHAIN_SERVICE);
-        const validAccounts = new Set(Object.values(ACCOUNT_BY_PROVIDER));
-        return creds.filter((c) => validAccounts.has(c.account)).map((c) => c.account);
-    }
-    catch {
-        return [];
-    }
+    return KEYCHAIN_PROVIDER_IDS.filter((p) => {
+        const v = process.env[ENV_BY_PROVIDER[p]];
+        return !!v && v.length >= 20;
+    });
 }
 /**
- * Load the API key for a given provider.
- * Priority: OS keychain (keytar) > environment variable.
+ * Load the API key for a given provider from the environment.
  * Ollama returns '' when no key is found (keyless).
  *
  * @throws {ProviderKeyMissingError} when no key found for non-ollama providers.
  */
 export async function loadKeyForProvider(provider) {
-    const kt = await loadKeytar();
-    if (kt) {
-        try {
-            const k = await kt.getPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_PROVIDER[provider]);
-            if (k && k.length >= 20) {
-                redactor.enrollSecret(k);
-                return k;
-            }
-        }
-        catch {
-            /* ignore keytar backend failures */
-        }
-    }
     const envKey = process.env[ENV_BY_PROVIDER[provider]];
     if (envKey && envKey.length >= 20) {
         redactor.enrollSecret(envKey);
         return envKey;
     }
-    // Fallback: check user-settings.json providers config (lazy import to avoid circular deps)
-    const settingsField = SETTINGS_KEY_MAP[provider];
-    if (settingsField) {
-        try {
-            const { loadUserSettings } = await import("../utils/settings.js");
-            const providers = loadUserSettings().providers;
-            const settingsKey = providers?.[settingsField]?.apiKey;
-            if (settingsKey && settingsKey.length >= 20) {
-                redactor.enrollSecret(settingsKey);
-                return settingsKey;
-            }
-        }
-        catch {
-            /* settings load failed — continue to error */
-        }
-    }
     // Ollama may be keyless
     if (provider === "ollama")
         return "";
     throw new ProviderKeyMissingError(provider);
 }
 /**
- * Return the list of providers that currently have credentials available — checked across
- * OS keychain, environment variables, and user-settings.json. `ollama` is always included
+ * Return the list of providers that currently have credentials available —
+ * either an env API key or a stored OAuth token. `ollama` is always included
  * because it is keyless. Order is stable for UI rendering.
  */
 export async function getConfiguredProviders() {
     const order = ALL_PROVIDER_IDS;
     const stored = new Set(await listStoredProviders());
-    let settingsProviders = {};
-    try {
-        const { loadUserSettings } = await import("../utils/settings.js");
-        settingsProviders = (loadUserSettings().providers ?? {});
-    }
-    catch {
-        /* settings unreadable — keychain + env still work */
-    }
     // OAuth-authenticated providers (no API key, but tokens stored via `keys
     // login`) need to count as configured — otherwise the model picker silently
     // hides them. Source the eligible provider list from the OAuth registry so
@@ -216,25 +133,8 @@ export async function getConfiguredProviders() {
     }
     const configured = [];
     for (const p of order) {
-        if (p === "ollama") {
+        if (p === "ollama" || stored.has(p) || oauthAuthenticated.has(p)) {
             configured.push(p);
-            continue;
-        }
-        if (stored.has(p) || oauthAuthenticated.has(p)) {
-            configured.push(p);
-            continue;
-        }
-        const envKey = process.env[ENV_BY_PROVIDER[p]];
-        if (envKey && envKey.length >= 20) {
-            configured.push(p);
-            continue;
-        }
-        const settingsField = SETTINGS_KEY_MAP[p];
-        if (settingsField) {
-            const k = settingsProviders[settingsField]?.apiKey;
-            if (k && k.length >= 20) {
-                configured.push(p);
-            }
         }
     }
     return configured;
@@ -258,7 +158,7 @@ export async function getOAuthTokens(provider) {
 }
 /**
  * Find the first provider with an available API key.
- * Checks in priority order: anthropic, openai, google, deepseek, siliconflow, ollama.
+ * Checks in priority order: anthropic, openai, deepseek, ollama.
  * Returns null if no provider has a key (unlikely — ollama is keyless fallback).
  */
 export async function firstAvailableProvider() {
@@ -277,4 +177,91 @@ export async function firstAvailableProvider() {
     }
     return null;
 }
+/**
+ * One-time migration: move any legacy API keys — OS keychain (keytar) or
+ * `settings.json` (`providers.<p>.apiKey`) — into the env-store, then remove
+ * the legacy copies. Best-effort, idempotent, and never throws. Guarded by
+ * `settings.keysMigratedToEnv`. Runs once at startup before key resolution.
+ */
+export async function migrateLegacyKeysToEnv() {
+    let settingsMod;
+    try {
+        settingsMod = await import("../utils/settings.js");
+    }
+    catch (err) {
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[keychain] migration: settings unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return;
+    }
+    let settings;
+    try {
+        settings = settingsMod.loadUserSettings();
+    }
+    catch {
+        return;
+    }
+    if (settings.keysMigratedToEnv)
+        return;
+    // Legacy keytar reader — the dependency has been removed, so absence is the
+    // normal case. The specifier is assembled at runtime so the bundler
+    // (`bun build --compile`) does not try to statically resolve the missing
+    // module; when keytar isn't installed this import simply throws → null.
+    let keytar = null;
+    try {
+        const legacyKeytarSpecifier = ["key", "tar"].join("");
+        keytar = (await import(legacyKeytarSpecifier));
+    }
+    catch {
+        keytar = null;
+    }
+    const providersPatch = { ...(settings.providers ?? {}) };
+    let providersDirty = false;
+    for (const p of KEYCHAIN_PROVIDER_IDS) {
+        const envName = ENV_BY_PROVIDER[p];
+        if (process.env[envName])
+            continue; // already in env
+        let legacy = null;
+        if (keytar?.getPassword) {
+            try {
+                legacy = await keytar.getPassword("muonroi-cli", p);
+            }
+            catch {
+                legacy = null;
+            }
+        }
+        if (!legacy)
+            legacy = providersPatch[p]?.apiKey ?? null;
+        if (legacy && legacy.length >= 20) {
+            persistEnvVar(envName, legacy);
+            if (keytar?.deletePassword) {
+                try {
+                    await keytar.deletePassword("muonroi-cli", p);
+                }
+                catch {
+                    /* best-effort keychain cleanup */
+                }
+            }
+            if (providersPatch[p]?.apiKey) {
+                delete providersPatch[p].apiKey;
+                providersDirty = true;
+            }
+        }
+    }
+    const patch = { keysMigratedToEnv: true };
+    // Strip the legacy plaintext main key — it is no longer read (getApiKey is
+    // env-only). Passing undefined drops it from the persisted JSON.
+    if (settings.apiKey)
+        patch.apiKey = undefined;
+    if (providersDirty)
+        patch.providers = providersPatch;
+    try {
+        settingsMod.saveUserSettings(patch);
+    }
+    catch (err) {
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[keychain] migration: save failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
 //# sourceMappingURL=keychain.js.map

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