comfyui-mcp 0.22.0 → 0.23.1

package/dist/orchestrator/index.js

@@ -22,6 +22,7 @@ import { readUserMcpServers } from "../services/user-mcp-config.js";
 import { buildComfyuiMcpEnv, comfyuiSecretKeys, onComfyuiSecretsChanged, } from "../services/panel-secrets.js";
 import { CodexBackend } from "./codex-backend.js";
 import { GeminiBackend, GEMINI_DEFAULT_MODEL } from "./gemini-backend.js";
+import { allBackendReadiness } from "./backend-readiness.js";
 import { startPanelMcpHttpServer } from "./panel-mcp-http.js";
 import { readComfyuiCrashLog, formatCrashNote } from "../services/crash-log.js";
 import { QueueMonitor } from "../services/queue-monitor.js";
@@ -56,6 +57,8 @@ RESOLVING A TANGLED / TOGGLE-HEAVY WORKFLOW (Get/Set buses + rgthree-bypassed pi
 
 DOWNLOADING MODELS — use the download_model tool, NOT a raw shell download. When a workflow needs model weights you don't have (checkpoints, LoRAs, VAEs, text encoders, etc.), download them with the comfyui MCP download_model tool (or download_civitai_model for CivitAI): it streams the file into the correct ComfyUI models/ subfolder AND surfaces live progress in the panel's download tray so the user can watch it. Pass target_subfolder to land the file exactly where it belongs (e.g. 'loras', 'checkpoints', 'vae', 'text_encoders', or a nested path like 'loras/<subdir>'). Do NOT shell out to curl/wget/aria2 for model files — a raw shell download has no progress in the panel and can drop the file in the wrong place. Reserve the shell for things download_model can't do.
 
+HARDWARE & RUNTIME STATS — use the MCP tools, NOT the shell. For GPU / VRAM / CPU / RAM, CUDA/torch/python versions, and ComfyUI runtime stats, call the comfyui MCP get_system_stats (raw /system_stats) or get_environment (a summarized snapshot) — they read the CONNECTED ComfyUI's /system_stats and work for LOCAL and REMOTE targets alike. Do NOT shell out (nvidia-smi, PowerShell, wmic, python) for hardware info: the managed shell is sandboxed/read-only and rejects multi-line scripts, so those probes fail and only reach the orchestrator host anyway, not a remote ComfyUI. The startup ENVIRONMENT line already summarizes the machine; when you need current or more detail, get_system_stats / get_environment are the source of truth.
+
 LOCAL-GPU (FREE) vs API NODES (PAID CREDITS) — and ASK before spending. ComfyUI workflows are either LOCAL — they run on the user's OWN GPU, which is free — or they use API NODES (hosted/partner services) that consume the user's PAID api credits. The bundled installer packs (list_packs) are ALL local/free; ComfyUI's official templates and any ad-hoc or generated workflow MAY use API nodes. BEFORE you build OR load any workflow that uses API nodes, you MUST ASK the user whether to use the free local GPU or paid api credits, and NEVER silently spend credits. To tell the difference reliably, call check_workflow_runtime(pack:<name> or graph:<json>) — it returns { runtime: 'local'|'api'|'mixed'|'unknown', usesApiNodes, apiNodes[] } by scanning the graph's nodes against the server's API-node set; treat 'api'/'mixed' (usesApiNodes:true) AND 'unknown' (unclassifiable nodes that could be paid) as POSSIBLY PAID and stop to ask — only 'local' is confirmed free. DEFAULT TO / PREFER the local pack unless the user explicitly opts into API nodes. Packs are always safe to load without asking; check ad-hoc/template workflows first.
 
 You also have the comfyui MCP tools to generate images, video, and audio and to inspect, download models for, and manage their ComfyUI instance. Use them to actually do what's asked, then tell them what you did and name or link any output. If a request is ambiguous, make a sensible choice and say what you chose rather than stalling.
@@ -342,11 +345,28 @@ export async function runPanelOrchestrator() {
     // mode — so it generates against the live ComfyUI over COMFYUI_URL and never
     // tries to bind the bridge port we own here.
     const mcpEntry = fileURLToPath(new URL("../index.js", import.meta.url));
-    const comfyuiUrl = process.env.COMFYUI_URL ?? "http://127.0.0.1:8188";
-    // ComfyUI install path — when set, the spawned agent's MCP runs in LOCAL mode,
-    // so download_model / apply_manifest / installer-pack / model-scan tools work
-    // instead of degrading to remote-only. The panel pack supplies this.
-    const comfyuiPath = process.env.COMFYUI_PATH;
+    // Mutable: the panel sends the ComfyUI URL it was SERVED FROM (window.location)
+    // in `hello`, and the orchestrator retargets to it (applyComfyuiUrl) — so
+    // `--panel-orchestrator` boots on the localhost default and auto-points at
+    // whatever ComfyUI (local or a RunPod proxy) the browser is actually on. No
+    // `connect <url>` needed.
+    let comfyuiUrl = process.env.COMFYUI_URL ?? "http://127.0.0.1:8188";
+    // ComfyUI install path — when set AND the target is loopback, the spawned agent's
+    // MCP runs in LOCAL mode (download_model / apply_manifest / installer-pack /
+    // model-scan tools). A REMOTE target (non-loopback) forces remote-only, so we
+    // drop the path. `envComfyuiPath` is the orchestrator's own env value; the live
+    // `comfyuiPath` is derived from it + the current target.
+    const envComfyuiPath = process.env.COMFYUI_PATH;
+    const isLoopbackUrl = (u) => {
+        try {
+            const h = new URL(u).hostname.toLowerCase();
+            return h === "127.0.0.1" || h === "localhost" || h === "::1" || h === "0.0.0.0" || h === "";
+        }
+        catch {
+            return true;
+        }
+    };
+    let comfyuiPath = isLoopbackUrl(comfyuiUrl) ? envComfyuiPath : undefined;
     const model = process.env.COMFYUI_MCP_PANEL_MODEL ?? "claude-opus-4-8";
     const envEffort = process.env.COMFYUI_MCP_PANEL_EFFORT;
     const effort = isEffort(envEffort) ? envEffort : undefined;
@@ -409,12 +429,31 @@ export async function runPanelOrchestrator() {
     // COMFYUI_MCP_GEMINI_MODEL (default gemini-2.5-pro). The model is applied at spawn
     // via the CLI `--model` flag (ACP exposes no per-session model setter).
     const geminiModel = process.env.COMFYUI_MCP_GEMINI_MODEL ?? GEMINI_DEFAULT_MODEL;
-    const isCodex = backendId === "codex";
-    const isGemini = backendId === "gemini";
-    // Codex + Gemini both drive the live canvas through the loopback HTTP panel MCP
-    // (neither can host an in-process SDK MCP server like Claude does), so several
-    // branches below treat them together.
-    const isHttpPanelBackend = isCodex || isGemini;
+    // ── Per-tab backend (single-port multi-provider) ──────────────────────────
+    // ONE orchestrator on ONE bridge port serves ALL providers; the panel picks a
+    // provider per tab via the `hello`/`set_backend` handshake, instead of the node
+    // spawning one process per provider on its own port (9180/9181/9182). Internally
+    // each (panel tab, backend) pair is one agent addressed by a composite key
+    // `tabId::backend`, so switching provider starts a FRESH session for that
+    // provider (the panel replays the transcript to seed it) while a same-provider
+    // reconnect RESUMES. `backendId`/`codexModel`/`geminiModel` above are the
+    // DEFAULT + per-provider model config; the process is no longer pinned to one.
+    const KNOWN_BACKENDS = new Set(["claude", "codex", "gemini"]);
+    const defaultBackend = KNOWN_BACKENDS.has(backendId) ? backendId : "claude";
+    const AGENT_KEY_SEP = "::";
+    const tabBackends = new Map(); // panel tabId -> selected backend
+    const backendForTab = (panelTabId) => tabBackends.get(panelTabId) ?? defaultBackend;
+    const agentKeyFor = (panelTabId) => panelTabId + AGENT_KEY_SEP + backendForTab(panelTabId);
+    // A panel tab id never contains "::"; backend names never do — so split on the
+    // LAST separator to recover each half from a composite key.
+    const panelTabOf = (key) => {
+        const i = key.lastIndexOf(AGENT_KEY_SEP);
+        return i >= 0 ? key.slice(0, i) : key;
+    };
+    const backendOf = (key) => {
+        const i = key.lastIndexOf(AGENT_KEY_SEP);
+        return i >= 0 ? key.slice(i + AGENT_KEY_SEP.length) : defaultBackend;
+    };
     // ---- live ENVIRONMENT-CAPABILITIES block ----
     // Gather the machine's facts ONCE at startup (CACHED) — OS/CPU/RAM from node,
     // GPU/VRAM/CUDA/torch/python/ComfyUI from /system_stats, Triton/SageAttention by
@@ -462,7 +501,9 @@ export async function runPanelOrchestrator() {
     // A panel-saved tool secret (CIVITAI_API_TOKEN, HF_TOKEN, …) is layered on top
     // by buildComfyuiMcpEnv() at SPAWN time, so the same headless tool surface — and
     // the same secrets — reach either provider.
-    const comfyuiBaseEnv = {
+    // A FUNCTION (not a frozen object) so it always reflects the CURRENT retargeted
+    // comfyuiUrl/comfyuiPath — makeHttpBackendMcpServers calls it per (re)spawn.
+    const comfyuiBaseEnv = () => ({
         COMFYUI_URL: comfyuiUrl,
         COMFYUI_MCP_PROGRESS_DIR: progressDir,
         ...(comfyuiPath ? { COMFYUI_PATH: comfyuiPath } : {}),
@@ -472,19 +513,23 @@ export async function runPanelOrchestrator() {
         ...(process.env.HF_TOKEN ? { HF_TOKEN: process.env.HF_TOKEN } : {}),
         // Test-only tool-call trace (knowledge-parity smoke). No-op unless set.
         ...(process.env.COMFYUI_MCP_TOOL_TRACE ? { COMFYUI_MCP_TOOL_TRACE: process.env.COMFYUI_MCP_TOOL_TRACE } : {}),
-    };
+    });
     // The orchestrator-hosted loopback HTTP MCP for panel_* tools. Started for the
     // non-Claude backends (Codex + Gemini), which can't host an in-process SDK MCP
     // server the way Claude does. Port: COMFYUI_MCP_PANEL_MCP_PORT, default
     // bridgePort+1 (loopback only).
+    // Start the loopback HTTP panel-MCP ALWAYS: with single-port multi-provider any
+    // tab may pick codex/gemini at runtime, and those backends drive the canvas
+    // through this server (Claude tabs use the in-process SDK server instead). The
+    // per-tab session routing (`urlFor(panelTabId)`) already isolates tabs.
     let panelMcpHttp = null;
-    if (isHttpPanelBackend) {
+    {
         const panelMcpPort = Number(process.env.COMFYUI_MCP_PANEL_MCP_PORT) || bridgePort + 1;
         try {
             panelMcpHttp = await startPanelMcpHttpServer(bridge, panelMcpPort);
         }
         catch (err) {
-            logger.error(`[panel-orchestrator] could not start the panel HTTP MCP on :${panelMcpPort} — ${backendId} will lack live-graph tools: ${err instanceof Error ? err.message : String(err)}`);
+            logger.error(`[panel-orchestrator] could not start the panel HTTP MCP on :${panelMcpPort} — codex/gemini tabs will lack live-graph tools: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     // Shared MCP server config for BOTH the Codex and Gemini backends — they take an
@@ -498,52 +543,61 @@ export async function runPanelOrchestrator() {
             args: [mcpEntry], // dist/index.js
             // Merge persisted tool secrets at SPAWN time so a respawn picks up a
             // just-saved CIVITAI_API_TOKEN / HF_TOKEN without a process restart.
-            env: buildComfyuiMcpEnv(comfyuiBaseEnv),
+            env: buildComfyuiMcpEnv(comfyuiBaseEnv()),
         },
         // Live-graph panel_* tools for THIS tab over the loopback HTTP MCP.
         ...(panelMcpHttp
             ? { panel: { transport: "http", url: panelMcpHttp.urlFor(tabId) } }
             : {}),
     });
-    const makeBackend = isCodex
-        ? (tabId) => new CodexBackend({
-            cwd: comfyuiPath ?? process.cwd(),
-            model: codexModel,
-            systemAppend: panelSystemAppend,
-            // Base ComfyUI URL so the backend can fetch image bytes from /view and
-            // deliver them to a turn as `localImage` input items (vision parity).
-            comfyuiUrl,
-            mcpServers: makeHttpBackendMcpServers(tabId),
-        })
-        : isGemini
-            ? (tabId) => new GeminiBackend({
+    // Build the provider backend for a composite agent key `panelTabId::backend`.
+    // Claude → undefined (PanelAgent uses its built-in in-process SDK backend);
+    // codex/gemini → their CLI-driven backend, wired to the panel_* tools over the
+    // loopback HTTP MCP for THIS panel tab's canvas (comfyuiUrl gives vision parity).
+    const makeBackend = (key) => {
+        const backend = backendOf(key);
+        const panelTabId = panelTabOf(key);
+        if (backend === "codex") {
+            return new CodexBackend({
+                cwd: comfyuiPath ?? process.cwd(),
+                model: codexModel,
+                systemAppend: panelSystemAppend,
+                comfyuiUrl,
+                mcpServers: makeHttpBackendMcpServers(panelTabId),
+            });
+        }
+        if (backend === "gemini") {
+            return new GeminiBackend({
                 cwd: comfyuiPath ?? process.cwd(),
                 model: geminiModel,
                 systemAppend: panelSystemAppend,
-                // Base ComfyUI URL so the backend can fetch image bytes from /view and
-                // deliver them inline as base64 image ContentBlocks (vision parity).
                 comfyuiUrl,
-                mcpServers: makeHttpBackendMcpServers(tabId),
-            })
-            : undefined;
-    if (isCodex) {
-        logger.info(`[panel-orchestrator] agent backend = codex (codex app-server); panel_* live-graph tools via loopback HTTP MCP${panelMcpHttp ? ` on :${panelMcpHttp.port}` : " UNAVAILABLE"} + headless comfyui MCP`);
-    }
-    else if (isGemini) {
-        logger.info(`[panel-orchestrator] agent backend = gemini (gemini --acp); model=${geminiModel}; panel_* live-graph tools via loopback HTTP MCP${panelMcpHttp ? ` on :${panelMcpHttp.port}` : " UNAVAILABLE"} + headless comfyui MCP`);
-    }
-    else if (backendId !== "claude") {
-        logger.warn(`[panel-orchestrator] unknown PANEL_AGENT_BACKEND "${backendId}" — defaulting to claude`);
-    }
-    // Readiness/model probing must route through the SELECTED backend (P1-2): in a
-    // non-Claude mode the panel's "ready" must NOT depend on Claude SDK/login health.
-    // A dedicated probe backend (not tied to a tab) supplies the model list and
-    // proves the CLI can start; Claude mode keeps its SDK probes.
-    const probeBackend = isCodex
-        ? new CodexBackend({ cwd: comfyuiPath ?? process.cwd(), model: codexModel })
-        : isGemini
-            ? new GeminiBackend({ cwd: comfyuiPath ?? process.cwd(), model: geminiModel })
-            : null;
+                mcpServers: makeHttpBackendMcpServers(panelTabId),
+            });
+        }
+        return undefined; // claude → built-in ClaudeBackend
+    };
+    logger.info(`[panel-orchestrator] single-port multi-provider: default backend=${defaultBackend}; ` +
+        `codex/gemini panel_* live-graph tools via loopback HTTP MCP${panelMcpHttp ? ` on :${panelMcpHttp.port}` : " UNAVAILABLE"} + headless comfyui MCP`);
+    // Readiness/model probing routes through the SELECTED backend PER TAB — a
+    // codex/gemini tab's "ready" must NOT depend on Claude SDK/login health. Claude
+    // uses fetchSupportedModels(); codex/gemini spin up a throwaway probe backend
+    // (which also proves the CLI can launch). Cached per backend so repeated hellos
+    // don't re-probe.
+    const probeBackends = new Map();
+    const getProbeBackend = (backend) => {
+        if (backend === "claude")
+            return null; // claude uses the SDK probe below
+        let pb = probeBackends.get(backend);
+        if (!pb) {
+            pb =
+                backend === "codex"
+                    ? new CodexBackend({ cwd: comfyuiPath ?? process.cwd(), model: codexModel })
+                    : new GeminiBackend({ cwd: comfyuiPath ?? process.cwd(), model: geminiModel });
+            probeBackends.set(backend, pb);
+        }
+        return pb;
+    };
     // Durable per-tab session ids (keyed by our bridge port), so a tab's agent
     // resumes its conversation even after the orchestrator PROCESS is killed and
     // respawned (a wedge auto-restart) — not just a soft reload.
@@ -577,42 +631,46 @@ export async function runPanelOrchestrator() {
         comfyuiUrl, // for fetching image bytes to inline into agent turns
         systemAppend: panelSystemAppend,
         pluginPath: pluginAvailable ? pluginPath : undefined,
-        // Live-graph control of the user's open workflow, per tab (in-process).
-        makePanelServer: (tabId) => createPanelMcpServer(bridge, tabId),
+        // In-process live-graph MCP for CLAUDE keys only (codex/gemini drive the
+        // canvas through the loopback HTTP MCP instead). Bound to the PANEL tab so
+        // panel_* tools reach the user's canvas regardless of the composite key.
+        makePanelServer: (key) => backendOf(key) === "claude" ? createPanelMcpServer(bridge, panelTabOf(key)) : undefined,
         mcpServers: buildMcpServers(),
-        onSay: (tabId, text, meta) => {
+        // NOTE: manager callbacks fire with the composite agent key `tabId::backend`;
+        // panelTabOf() recovers the PANEL tab so every push reaches the right socket.
+        onSay: (key, text, meta) => {
             // `id` lets the panel reconcile this committed message with its live
             // streaming preview (same id) instead of rendering a duplicate bubble.
-            bridge.push({ type: "say", text, id: meta?.id, streamed: meta?.streamed }, tabId);
+            bridge.push({ type: "say", text, id: meta?.id, streamed: meta?.streamed }, panelTabOf(key));
         },
         // Live streaming deltas → the panel's think-window + streaming reply bubble.
-        onStream: (tabId, ev) => {
-            bridge.push({ type: "stream", phase: ev.phase, id: ev.id, delta: ev.delta }, tabId);
+        onStream: (key, ev) => {
+            bridge.push({ type: "stream", phase: ev.phase, id: ev.id, delta: ev.delta }, panelTabOf(key));
         },
         // Per-response usage → the panel's context/usage meter (updates live).
-        onStatus: pushStatus,
+        onStatus: (key, status) => pushStatus(panelTabOf(key), status),
         // Report the SDK session id so the panel can persist it and resume on reload.
-        onSession: (tabId, sessionId) => {
-            bridge.push({ type: "session", session_id: sessionId }, tabId);
+        onSession: (key, sessionId) => {
+            bridge.push({ type: "session", session_id: sessionId }, panelTabOf(key));
         },
         // Per-turn rewind anchor (assistant UUID) → the panel stores it so a later
         // "rewind conversation to here" can fork the session at that point.
-        onTurnAnchor: (tabId, uuid) => {
-            bridge.push({ type: "turn_anchor", uuid }, tabId);
+        onTurnAnchor: (key, uuid) => {
+            bridge.push({ type: "turn_anchor", uuid }, panelTabOf(key));
         },
         // Turn lifecycle → the panel's "working" indicator (stays up through silent
         // tool work; clears on done).
-        onTurn: (tabId, state) => {
-            bridge.push({ type: "turn", state }, tabId);
+        onTurn: (key, state) => {
+            bridge.push({ type: "turn", state }, panelTabOf(key));
         },
         // Live extended-thinking token count → "thinking… (N)" indicator.
-        onThinking: (tabId, tokens) => {
-            bridge.push({ type: "thinking", tokens }, tabId);
+        onThinking: (key, tokens) => {
+            bridge.push({ type: "thinking", tokens }, panelTabOf(key));
         },
         // The agent dequeued a message (the true "read" moment) → flip that bubble
         // from queued/muted to read.
-        onSeen: (tabId, mid) => {
-            bridge.push({ type: "ack", ok: true, kind: "seen", mid }, tabId);
+        onSeen: (key, mid) => {
+            bridge.push({ type: "ack", ok: true, kind: "seen", mid }, panelTabOf(key));
         },
         // ROOT-CAUSE self-exit (the "bridge open but no panel agent responded" wedge):
         // a tab's agent died fatally (couldn't start, or its bounded self-restart gave
@@ -629,6 +687,52 @@ export async function runPanelOrchestrator() {
     // Let refreshEnvCapabilities() feed a freshly-gathered env block into agents
     // spawned after a ComfyUI restart/reconnect.
     liveManager = manager;
+    // Retarget the live ComfyUI from the panel's `hello.comfyui_url` (the URL the
+    // browser was SERVED FROM — window.location). This is what lets a bare
+    // `--panel-orchestrator` (booted on the localhost default) auto-point at whatever
+    // ComfyUI the user actually has open — local OR a RunPod proxy — with no
+    // `connect <url>`. Loopback → LOCAL mode (keep COMFYUI_PATH); non-loopback →
+    // REMOTE mode (drop the path). No-op if unchanged. Returns true if it retargeted.
+    const applyComfyuiUrl = (rawUrl) => {
+        if (typeof rawUrl !== "string")
+            return false;
+        const next = rawUrl.trim().replace(/\/+$/, "");
+        if (!next)
+            return false;
+        let host;
+        try {
+            const parsed = new URL(next);
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+                return false;
+            host = parsed.hostname;
+        }
+        catch {
+            return false; // not a valid URL — ignore (keep current target)
+        }
+        if (!host || next === comfyuiUrl)
+            return false;
+        const prev = comfyuiUrl;
+        comfyuiUrl = next;
+        comfyuiPath = isLoopbackUrl(next) ? envComfyuiPath : undefined;
+        // Point every provider at the new target: Claude via its rebuilt MCP env, the
+        // manager's image-fetch URL, then respawn active agents so the live comfyui MCP
+        // subprocess is recreated with the new COMFYUI_URL (no-op if none are running —
+        // the next spawn picks it up from the now-updated closures).
+        manager.setMcpServers(buildMcpServers());
+        manager.setComfyuiUrl(comfyuiUrl);
+        manager.restartAllForMcpEnv();
+        // Re-point the render watchdog and re-probe the env (remote vs local differs).
+        try {
+            QueueMonitor.stop();
+        }
+        catch {
+            /* best-effort */
+        }
+        QueueMonitor.start(comfyuiUrl);
+        void refreshEnvCapabilities();
+        logger.info(`[panel-orchestrator] retargeted ComfyUI ${prev} → ${comfyuiUrl} (${isLoopbackUrl(next) ? "local" : "remote"} mode) from panel hello`);
+        return true;
+    };
     // Tool secrets → comfyui MCP env: when the user saves a token via
     // panel_request_secret (e.g. CIVITAI_API_TOKEN for download_civitai_model), the
     // secret store persists it and fires this. We rebuild the comfyui server's spawn
@@ -650,52 +754,59 @@ export async function runPanelOrchestrator() {
     // works on the subscription lane) and cached. Pushed to each tab so the
     // panel's model/effort picker reflects what's actually available, with each
     // model's supported effort levels, instead of a hardcoded list.
-    let modelsPromise = null;
-    function ensureModels() {
-        if (!modelsPromise) {
-            // Non-Claude mode (P1-2): enumerate via the selected backend (which also
-            // proves the CLI can start = readiness) — NEVER the Claude SDK probe. Shape
-            // the backend's ModelChoice[] into the panel's ModelInfo[] form.
-            // NOTE (gemini): the Gemini probe is prepare()+listModels, which proves the
-            // CLI launches + the ACP handshake works but does NOT verify Google sign-in
-            // (ACP reports auth only at session/new), so the "ready" ack is PROVISIONAL
-            // for Gemini — a signed-out CLI still acks green here and surfaces a clear
-            // one-shot sign-in error on the first turn (no loop). The panel separately
-            // gates the UI via oauth_creds detection, so this is acceptable.
-            const probe = probeBackend
-                ? Promise.resolve(probeBackend.prepare?.())
-                    .then(() => probeBackend.listModels())
-                    .then((list) => 
-                // Carry the effort metadata through to the panel's ModelInfo — without
-                // this the supportsEffort/supportedEffortLevels the Codex backend
-                // advertises get dropped here and the panel hides the effort dropdown.
-                list.map((m) => ({
+    // Model list PER BACKEND — probed lazily and cached; an empty/failed probe is
+    // NOT cached so the next hello retries. Claude uses fetchSupportedModels() (the
+    // only path that works on the subscription lane); codex/gemini enumerate via a
+    // throwaway probe backend, which also proves the CLI can launch (= readiness).
+    // (Gemini's probe proves the CLI + ACP handshake but not Google sign-in, which
+    // ACP only reports at session/new — so its "ready" is provisional; a signed-out
+    // CLI surfaces a clear one-shot error on the first turn.)
+    const modelsByBackend = new Map();
+    function ensureModels(backend) {
+        let p = modelsByBackend.get(backend);
+        if (!p) {
+            const pb = getProbeBackend(backend);
+            const probe = pb
+                ? Promise.resolve(pb.prepare?.())
+                    .then(() => pb.listModels())
+                    .then((list) => list.map((m) => ({
                     value: m.id,
                     displayName: m.label ?? m.id,
                     ...(m.supportsEffort != null ? { supportsEffort: m.supportsEffort } : {}),
                     ...(m.supportedEffortLevels ? { supportedEffortLevels: m.supportedEffortLevels } : {}),
                 })))
                     .catch((err) => {
-                    logger.warn(`[panel-orchestrator] codex model probe failed: ${err instanceof Error ? err.message : String(err)}`);
+                    logger.warn(`[panel-orchestrator] ${backend} model probe failed: ${err instanceof Error ? err.message : String(err)}`);
                     return [];
                 })
                 : fetchSupportedModels(model);
-            modelsPromise = probe.then((list) => {
-                // Don't cache an empty/failed probe forever — let the next hello retry.
+            p = probe.then((list) => {
                 if (!list.length)
-                    modelsPromise = null;
+                    modelsByBackend.delete(backend); // don't cache a failure
                 return list;
             });
+            modelsByBackend.set(backend, p);
         }
-        return modelsPromise;
+        return p;
+    }
+    // The model to highlight as "current" for a backend: the panel's configured
+    // model for claude; the env override (or account default = the list's own
+    // current) for codex/gemini.
+    function currentModelFor(backend) {
+        if (backend === "codex")
+            return codexModel;
+        if (backend === "gemini")
+            return geminiModel;
+        return model;
     }
-    function pushModels(tabId) {
-        void ensureModels()
+    function pushModels(panelTabId) {
+        const backend = backendForTab(panelTabId);
+        void ensureModels(backend)
             .then((models) => {
             if (models.length) {
-                // `backend` rides on the models frame so the panel's backend picker can
-                // reflect which provider this orchestrator is actually running as.
-                bridge.push({ type: "models", models, current: model, backend: backendId }, tabId);
+                // `backend` rides on the models frame so the panel's picker reflects the
+                // provider THIS tab selected (single-port multi-provider).
+                bridge.push({ type: "models", models, current: currentModelFor(backend), backend }, panelTabId);
             }
         })
             .catch(() => {
@@ -720,10 +831,8 @@ export async function runPanelOrchestrator() {
     // the built-ins that make sense inside the ComfyUI panel chat.
     const PANEL_SLASH_ALLOWLIST = new Set(["compact", "context", "usage", "loop", "goal", "clear"]);
     function pushCommands(tabId) {
-        // Non-Claude mode (P1-2): no Claude slash-commands — skip the Claude SDK probe
-        // entirely (CODEX/GEMINI_CAPABILITIES.slashCommands === false).
-        if (isHttpPanelBackend)
-            return;
+        // Claude-only: SDK slash-commands don't exist for codex/gemini. Callers already
+        // gate this to claude tabs (single-port multi-provider), so no backend check here.
         void ensureCommands()
             .then((commands) => {
             const useful = commands.filter((c) => PANEL_SLASH_ALLOWLIST.has(c.name));
@@ -734,75 +843,132 @@ export async function runPanelOrchestrator() {
             /* probe already logged; panel just won't show SDK commands */
         });
     }
+    // Real per-provider readiness, computed HERE (the machine running the agents)
+    // and pushed over the bridge so the panel's provider switcher reflects the
+    // truth — not the ComfyUI host's probe, which is blind to the laptop in the
+    // "remote ComfyUI, local agent" model (and never sees Claude's SDK, which has
+    // no CLI). The panel prefers this frame over its GET /backends probe.
+    function pushReadiness(tabId) {
+        try {
+            const { backends, any_ready } = allBackendReadiness(KNOWN_BACKENDS);
+            bridge.push({ type: "backends", backends, any_ready }, tabId);
+        }
+        catch (err) {
+            logger.warn(`[panel-orchestrator] readiness probe failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     bridge.onPanelMessage = (event) => {
         // Connect ack: the instant a panel tab connects, the orchestrator announces
         // itself so "connected" means "a real agent is attending" — not merely "a
         // socket is open." A bare/undriven bridge stays silent, so the panel can
         // tell the difference (and warn if no ack arrives).
         if (event.type === "hello" && event.tab_id) {
-            // Reload restore: the panel re-sends the last session id it saw so the
-            // agent's memory continues. Only honored before the tab's agent spawns.
+            const panelTab = event.tab_id;
+            // Retarget ComfyUI to the URL the browser was served from (window.location),
+            // BEFORE the readiness probe so the "ready" ack reflects the right instance.
+            applyComfyuiUrl(event.comfyui_url);
+            // Per-tab backend selection (single-port multi-provider). The panel names
+            // its chosen provider on connect (and on a switch it re-sends hello / a
+            // set_backend); absent or unknown → the default.
+            const reqBackend = typeof event.backend === "string"
+                ? event.backend.toLowerCase()
+                : undefined;
+            const backend = reqBackend && KNOWN_BACKENDS.has(reqBackend) ? reqBackend : defaultBackend;
+            const prev = tabBackends.get(panelTab);
+            if (prev && prev !== backend) {
+                // Provider switch: retire the previous provider's agent for this tab so it
+                // doesn't linger. The new provider starts a FRESH session (the panel
+                // replays the transcript as context on its first message to seed it).
+                manager.reset(panelTab + AGENT_KEY_SEP + prev);
+            }
+            tabBackends.set(panelTab, backend);
+            const key = panelTab + AGENT_KEY_SEP + backend;
+            // Reload restore: the panel re-sends the last session id it saw. Honored
+            // only for a SAME-provider (re)connect — a switch always starts fresh. The
+            // orchestrator's own store stays authoritative on the actual spawn.
             const resume = typeof event.resume === "string" ? event.resume : undefined;
-            if (resume)
-                manager.setResume(event.tab_id, resume);
-            // Send the live model list so the picker reflects the real subscription,
-            // and the SDK's slash commands so the composer can surface them.
-            pushModels(event.tab_id);
-            pushCommands(event.tab_id);
+            if (resume && (!prev || prev === backend))
+                manager.setResume(key, resume);
+            // Live model list for the picker; SDK slash commands are Claude-only.
+            pushModels(panelTab);
+            // Truthful provider readiness (this machine runs the agents), so the
+            // switcher stops falsely showing "CLI not installed" behind a remote pod.
+            pushReadiness(panelTab);
+            if (backend === "claude")
+                pushCommands(panelTab);
             // Re-push the last usage so the context meter isn't blank after a reload.
-            const lastStatus = manager.lastStatusFor(event.tab_id);
+            const lastStatus = manager.lastStatusFor(key);
             if (lastStatus)
-                pushStatus(event.tab_id, lastStatus);
-            const tabId = event.tab_id;
+                pushStatus(panelTab, lastStatus);
             const now = Date.now();
-            if (now - (lastAckAt.get(tabId) ?? 0) < ACK_DEBOUNCE_MS)
+            if (now - (lastAckAt.get(panelTab) ?? 0) < ACK_DEBOUNCE_MS)
                 return;
-            lastAckAt.set(tabId, now);
-            // TRUTHFUL "connected": only claim ready after PROVING the SDK can run, by
-            // probing the model list (same machinery the agent uses to spawn). If the
-            // probe fails — the "connected but dead" wedge — say so and send a degraded
-            // ack instead of a green ready, so the panel can show the real state.
-            void ensureModels()
+            lastAckAt.set(panelTab, now);
+            const isCx = backend === "codex";
+            const isGm = backend === "gemini";
+            // TRUTHFUL "connected": only claim ready after PROVING the SELECTED backend
+            // can run, by probing its model list. If the probe fails — the "connected
+            // but dead" wedge — send a degraded ack so the panel shows the real state.
+            void ensureModels(backend)
                 .then((models) => {
                 if (models.length) {
-                    // Greet only on a FRESH session. On a reconnect/resume — a panel swap,
-                    // a WS blip, or a real restart (all carry `resume`) — the user already
-                    // has their thread, so re-greeting is just noise. The ack still fires.
-                    // Backend-appropriate messaging (P1-2): each provider must name its own
-                    // account/auth, and the agent label is that provider's model (Codex/
-                    // Gemini account default when the env override is unset).
-                    const agentLabel = isCodex
+                    const agentLabel = isCx
                         ? (codexModel ?? models[0].value ?? "Codex")
-                        : isGemini
+                        : isGm
                             ? (geminiModel ?? models[0].value ?? "Gemini")
                             : model;
+                    // Greet only on a FRESH session (a resume/reconnect already has the thread).
                     if (!resume) {
-                        const readyText = isCodex
+                        const readyText = isCx
                             ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Codex (ChatGPT) account. Ask away.`
-                            : isGemini
+                            : isGm
                                 ? `🟢 comfyui-mcp agent ready — ${agentLabel} on your Google account (Gemini Code Assist). Ask away.`
                                 : `🟢 comfyui-mcp agent ready — ${agentLabel} on your Claude subscription. Ask away.`;
-                        bridge.push({ type: "say", text: readyText }, tabId);
+                        bridge.push({ type: "say", text: readyText }, panelTab);
                     }
-                    bridge.push({ type: "ack", ok: true, kind: "ready", agent: agentLabel, backend: backendId }, tabId);
-                    logger.info(`[panel-orchestrator] tab ${tabId.slice(0, 8)} connected — agent healthy, sent ready ack`);
+                    bridge.push({ type: "ack", ok: true, kind: "ready", agent: agentLabel, backend }, panelTab);
+                    logger.info(`[panel-orchestrator] tab ${panelTab.slice(0, 8)} connected (${backend}) — agent healthy, ready ack`);
                 }
                 else {
-                    const degradedText = isCodex
+                    const degradedText = isCx
                         ? "⚠️ The background agent isn't responding — the Codex app-server couldn't start. Make sure Codex is installed and signed in (run `codex login`), then Disconnect → Connect to retry."
-                        : isGemini
+                        : isGm
                             ? "⚠️ The background agent isn't responding — the Gemini CLI couldn't start. Make sure the Gemini CLI is installed and signed in (run `gemini` once and complete the Google sign-in), then Disconnect → Connect to retry."
                             : "⚠️ The background agent isn't responding — the Claude Agent SDK couldn't start. Make sure you're signed in (run `claude` once), then Disconnect → Connect to retry.";
-                    bridge.push({ type: "say", text: degradedText }, tabId);
-                    bridge.push({ type: "ack", ok: false, kind: "degraded" }, tabId);
-                    logger.warn(`[panel-orchestrator] tab ${tabId.slice(0, 8)} connected but model probe empty — sent degraded ack`);
+                    bridge.push({ type: "say", text: degradedText }, panelTab);
+                    bridge.push({ type: "ack", ok: false, kind: "degraded" }, panelTab);
+                    logger.warn(`[panel-orchestrator] tab ${panelTab.slice(0, 8)} connected (${backend}) but model probe empty — degraded ack`);
                 }
             })
                 .catch(() => {
-                bridge.push({ type: "ack", ok: false, kind: "degraded" }, tabId);
+                bridge.push({ type: "ack", ok: false, kind: "degraded" }, panelTab);
             });
             return;
         }
+        // Provider switch WITHOUT a reconnect (single-port multi-provider): the panel
+        // picked a different backend chip. Retire the old provider's agent, remember
+        // the new one, and re-advertise its models. The panel replays the transcript
+        // as context on its next message so the fresh provider has the conversation.
+        if (event.type === "set_backend" && event.tab_id) {
+            const panelTab = event.tab_id;
+            const reqBackend = typeof event.backend === "string"
+                ? event.backend.toLowerCase()
+                : "";
+            if (!KNOWN_BACKENDS.has(reqBackend)) {
+                bridge.push({ type: "ack", ok: false, kind: "set_backend", message: `unknown backend '${reqBackend}'` }, panelTab);
+                return;
+            }
+            const prev = tabBackends.get(panelTab) ?? defaultBackend;
+            if (prev !== reqBackend)
+                manager.reset(panelTab + AGENT_KEY_SEP + prev);
+            tabBackends.set(panelTab, reqBackend);
+            pushModels(panelTab);
+            if (reqBackend === "claude")
+                pushCommands(panelTab);
+            bridge.push({ type: "ack", ok: true, kind: "set_backend", backend: reqBackend }, panelTab);
+            logger.info(`[panel-orchestrator] tab ${panelTab.slice(0, 8)} switched backend ${prev} → ${reqBackend}`);
+            return;
+        }
         // Live panel config (currently just the render-stall threshold). Applied
         // immediately, no reconnect — the next turn's watchdog check uses the new
         // value. Sent by the panel on connect and whenever the setting changes.
@@ -830,13 +996,13 @@ export async function runPanelOrchestrator() {
                 // makes the SDK session hang on init. (Defense in depth; the panel only
                 // sends ids from the live catalog.)
                 if (nextModel) {
-                    const known = await ensureModels().catch(() => []);
+                    const known = await ensureModels(backendForTab(tabId)).catch(() => []);
                     if (known.length && !known.some((m) => m.value === nextModel)) {
                         logger.warn(`[panel-orchestrator] ignoring unknown model "${nextModel}" — keeping current`);
                         nextModel = undefined;
                     }
                 }
-                const applied = await manager.setOptions(tabId, { model: nextModel, effort: nextEffort });
+                const applied = await manager.setOptions(agentKeyFor(tabId), { model: nextModel, effort: nextEffort });
                 bridge.push({
                     type: "ack",
                     ok: true,
@@ -862,11 +1028,11 @@ export async function runPanelOrchestrator() {
             // look at me") so the agent stops and fixes it instead of running blind.
             // Everything else (e.g. a finished render's images) is enqueued normally.
             if (ev.kind === "run_error") {
-                void manager.injectRunError(event.tab_id, ev.error ?? "unknown error");
+                void manager.injectRunError(agentKeyFor(event.tab_id), ev.error ?? "unknown error");
                 logger.info(`[panel-orchestrator] tab ${event.tab_id.slice(0, 8)} run_error → agent (interrupt)`);
                 return;
             }
-            const delivered = manager.injectEvent(event.tab_id, ev);
+            const delivered = manager.injectEvent(agentKeyFor(event.tab_id), ev);
             if (delivered) {
                 logger.info(`[panel-orchestrator] tab ${event.tab_id.slice(0, 8)} event → agent: ${event.kind}`);
             }
@@ -880,7 +1046,7 @@ export async function runPanelOrchestrator() {
             // interrupted turn so BOTH messages get answered; a plain Stop/Ctrl+C/Esc
             // sends a bare interrupt and must NOT re-run the stopped turn.
             const requeueInFlight = event.requeue === true;
-            void manager.interrupt(tabId, { requeueInFlight });
+            void manager.interrupt(agentKeyFor(tabId), { requeueInFlight });
             bridge.push({ type: "ack", ok: true, kind: "interrupt" }, tabId);
             logger.info(`[panel-orchestrator] tab ${tabId.slice(0, 8)} interrupted${requeueInFlight ? " (send-now: re-queue)" : ""}`);
             return;
@@ -890,7 +1056,7 @@ export async function runPanelOrchestrator() {
         if (event.type === "cancel_message" && event.tab_id) {
             const tabId = event.tab_id;
             const mid = typeof event.mid === "string" ? event.mid : undefined;
-            const removed = mid ? manager.cancelQueued(tabId, mid) : false;
+            const removed = mid ? manager.cancelQueued(agentKeyFor(tabId), mid) : false;
             bridge.push({ type: "ack", ok: true, kind: "cancel_message", mid, removed }, tabId);
             return;
         }
@@ -900,7 +1066,7 @@ export async function runPanelOrchestrator() {
             const tabId = event.tab_id;
             // reset() is synchronous (map cleared now), so no concurrent send() can
             // spawn an agent before we report the cleared session.
-            manager.reset(tabId);
+            manager.reset(agentKeyFor(tabId));
             bridge.push({ type: "session", session_id: null }, tabId);
             bridge.push({ type: "ack", ok: true, kind: "new_session" }, tabId);
             return;
@@ -912,7 +1078,7 @@ export async function runPanelOrchestrator() {
         if (event.type === "rewind" && event.tab_id) {
             const tabId = event.tab_id;
             const anchor = typeof event.anchor === "string" ? event.anchor : null;
-            const ok = manager.rewind(tabId, anchor);
+            const ok = manager.rewind(agentKeyFor(tabId), anchor);
             bridge.push({ type: "ack", ok, kind: "rewind" }, tabId);
             logger.info(`[panel-orchestrator] tab ${tabId.slice(0, 8)} rewind (anchor=${anchor ? anchor.slice(0, 8) : "fresh"}, ok=${ok})`);
             return;
@@ -923,7 +1089,7 @@ export async function runPanelOrchestrator() {
             const order = Array.isArray(event.order)
                 ? event.order.filter((m) => typeof m === "string")
                 : [];
-            const ok = manager.reorderQueue(tabId, order);
+            const ok = manager.reorderQueue(agentKeyFor(tabId), order);
             bridge.push({ type: "ack", ok, kind: "reorder" }, tabId);
             logger.info(`[panel-orchestrator] tab ${tabId.slice(0, 8)} reorder queue (${order.length} mids, ok=${ok})`);
             return;
@@ -934,9 +1100,10 @@ export async function runPanelOrchestrator() {
         if (event.type === "resume_session" && event.tab_id) {
             const tabId = event.tab_id;
             const sid = typeof event.session_id === "string" ? event.session_id : undefined;
-            manager.reset(tabId);
+            const key = agentKeyFor(tabId);
+            manager.reset(key);
             if (sid)
-                manager.setResume(tabId, sid);
+                manager.setResume(key, sid);
             bridge.push({ type: "ack", ok: true, kind: "resume_session" }, tabId);
             return;
         }
@@ -1000,7 +1167,17 @@ export async function runPanelOrchestrator() {
         catch (err) {
             logger.debug(`[panel-orchestrator] queue-note check failed (ignored): ${err instanceof Error ? err.message : String(err)}`);
         }
-        manager.send(event.tab_id, outText, {
+        // Transcript replay (single-port provider switch): the panel sends the prior
+        // conversation as `context` on the FIRST message to a freshly-switched
+        // provider, so the new backend has the thread (minus internal session data —
+        // thinking/tool traces/cache aren't portable across providers). Prepend it the
+        // same way crash/queue notes are, so it seeds the fresh session's first turn.
+        const replay = typeof event.context === "string"
+            ? event.context.trim()
+            : "";
+        if (replay)
+            outText = `${replay}\n\n${outText}`;
+        manager.send(agentKeyFor(event.tab_id), outText, {
             title: event.title,
             images: event.images,
             mid: userMid,
@@ -1083,9 +1260,11 @@ export async function runPanelOrchestrator() {
         QueueMonitor.stop();
         unsubscribeSecrets();
         await manager.stopAll();
-        // Dispose the readiness-probe backend (kills its Codex/Gemini CLI child).
-        if (probeBackend?.close)
-            await probeBackend.close().catch(() => { });
+        // Dispose the readiness-probe backends (kills each Codex/Gemini CLI child).
+        for (const pb of probeBackends.values()) {
+            if (pb.close)
+                await pb.close().catch(() => { });
+        }
         // Tear down the loopback panel HTTP MCP (codex/gemini mode only).
         if (panelMcpHttp)
             await panelMcpHttp.stop().catch(() => { });