comfyui-mcp 0.23.4 → 0.24.0

package/dist/orchestrator/ollama-backend.js

@@ -0,0 +1,668 @@
+// Ollama local-LLM adapter for the panel orchestrator (issue #97's panel phase).
+//
+// Unlike the Claude/Codex/Gemini adapters, the "provider" here is a plain HTTP
+// daemon with OpenAI-style tool calling and NO agent harness — so this backend
+// owns the whole agentic loop itself: it streams /api/chat NDJSON, dispatches
+// tool calls, and feeds results back until the model produces a final answer.
+//
+// Local models can't survive the full ~200-schema comfyui surface plus ~40
+// panel_* schemas, so the model sees exactly SIX tools (the "tool router"
+// pattern from issue #97):
+//   list_tools / describe_tool / call_tool      — passthrough to a headless
+//     comfyui MCP subprocess spawned in COMPACT mode (3 meta-tools built in)
+//   panel_list_tools / panel_describe_tool / panel_call_tool — synthesized
+//     here over the orchestrator's loopback panel HTTP MCP (live-graph tools)
+import { randomUUID } from "node:crypto";
+import { logger } from "../utils/logger.js";
+import { OLLAMA_CAPABILITIES } from "./agent-backend.js";
+/** Convert the neutral in-memory history to the OpenAI wire shape: tool-call
+ *  arguments must be JSON STRINGS, every call needs an id, and tool results
+ *  pair by tool_call_id (tool_name is an Ollama-ism the strict endpoints
+ *  reject). */
+function toOpenAiMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === "assistant" && m.tool_calls?.length) {
+            return {
+                role: "assistant",
+                content: m.content || null,
+                tool_calls: m.tool_calls.map((tc, i) => ({
+                    id: tc.id ?? `call_${i}`,
+                    type: "function",
+                    function: {
+                        name: tc.function.name,
+                        arguments: typeof tc.function.arguments === "string"
+                            ? tc.function.arguments
+                            : JSON.stringify(tc.function.arguments ?? {}),
+                    },
+                })),
+            };
+        }
+        if (m.role === "tool") {
+            return { role: "tool", tool_call_id: m.tool_call_id ?? "call_0", content: m.content };
+        }
+        return { role: m.role, content: m.content };
+    });
+}
+// The LLM Arena's best performer (scripts/llm-arena.mjs): 9/10, cleanest runs.
+const DEFAULT_MODEL = "gemma4:e4b";
+const MAX_TOOL_ROUNDS = 32;
+/**
+ * The Ollama system prompt REPLACES the frontier panel prompt: that one is
+ * thousands of tokens and instructs the agent to call dozens of tools BY NAME
+ * (panel_get_graph, list_packs, …) that don't exist on this backend's 6-tool
+ * router — a small model obeys it, hits "unknown tool", and gives up. This one
+ * is short, router-shaped, and (deliberately, for local models) does NOT carry
+ * the NSFW consent-gate flow — only the absolute hard limits.
+ */
+const OLLAMA_SYSTEM_PROMPT = [
+    "You are the ComfyUI agent in a sidebar panel, driving the user's live ComfyUI graph and server. Answer in normal Markdown.",
+    "",
+    "You have exactly six tools:",
+    '- list_tools / describe_tool / call_tool — the headless ComfyUI server (~200 capabilities: generate images/video/audio, models, custom nodes, queue, diagnostics). Flow: list_tools {"search": ...} → describe_tool {"name": ...} → call_tool {"name": ..., "args": {...}}.',
+    "- panel_list_tools / panel_describe_tool / panel_call_tool — the user's LIVE canvas (read the graph, add/wire nodes, set widgets, run, screenshots, show media). Same flow.",
+    "",
+    "Rules:",
+    "- Catalog entries are tool NAMES, not data. Finish every task by actually running tools; never invent results.",
+    "- Describe a tool before its first call so you use the right parameters. If a call errors, read the error — it includes the expected schema — fix the args and retry.",
+    "- To see or show any generated image/video, run the panel_show_media tool via panel_call_tool.",
+    "- Workflows with API nodes cost the user PAID credits; local-GPU workflows are free. Ask before anything that might spend credits.",
+].join("\n");
+function msgOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function textOf(result) {
+    return (result.content ?? [])
+        .filter((c) => c.type === "text")
+        .map((c) => c.text ?? "")
+        .join("\n");
+}
+function firstSentence(text, maxLen = 160) {
+    const line = (text.split(/(?<=\.)\s+/, 1)[0] ?? text).replace(/\s+/g, " ").trim();
+    return line.length <= maxLen ? line : `${line.slice(0, maxLen - 1).trimEnd()}…`;
+}
+/** Does this id look like a model this backend can run? PanelAgent
+ *  unconditionally passes the panel's Claude model as opts.model — this guard
+ *  keeps the configured model in charge unless the panel explicitly picked one
+ *  of ours. Ollama tags carry a ":" (qwen3:4b); hosted OpenAI-compatible slugs
+ *  carry a "/" vendor prefix (deepseek/deepseek-v3.2, anthropic/claude-…).
+ *  Mirrors gemini-backend's isGeminiModel. */
+export function isOllamaModel(id) {
+    return (id.includes(":") || id.includes("/")) && !/^claude|^gpt|^gemini/i.test(id);
+}
+export class OllamaBackend {
+    id = "ollama";
+    capabilities = OLLAMA_CAPABILITIES;
+    deps;
+    host;
+    model;
+    disposed = false;
+    prepared = false;
+    /** In-flight turn abort — interrupt() aborts the current fetch/loop. */
+    turnAbort = null;
+    comfy = null;
+    panel = null;
+    /** comfyui compact meta-tool defs (from tools/list) — handed to the model verbatim. */
+    comfyTools = [];
+    /** panel_* tool list (full defs stay HERE; the model gets 3 meta-tools). */
+    panelTools = [];
+    /** Conversation history for the live session (Ollama is stateless per request). */
+    history = [];
+    sessionId = null;
+    /** Wire dialect (see OllamaBackendDeps.api). */
+    api;
+    apiKey;
+    constructor(deps = {}) {
+        this.deps = deps;
+        this.api = deps.api ?? "ollama";
+        this.apiKey = deps.apiKey;
+        this.host = (deps.host ?? process.env.OLLAMA_HOST ?? "http://127.0.0.1:11434").replace(/\/$/, "");
+        this.model = deps.model ?? DEFAULT_MODEL;
+    }
+    authHeaders() {
+        return this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {};
+    }
+    async prepare() {
+        if (this.disposed)
+            throw new Error("ollama backend is closed.");
+        if (this.prepared)
+            return;
+        let version = "?";
+        try {
+            if (this.api === "openai") {
+                const res = await fetch(`${this.host}/models`, {
+                    headers: this.authHeaders(),
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (!res.ok)
+                    throw new Error(`http ${res.status}`);
+                version = "openai-compatible";
+            }
+            else {
+                const res = await fetch(`${this.host}/api/version`, { signal: AbortSignal.timeout(3000) });
+                if (!res.ok)
+                    throw new Error(`http ${res.status}`);
+                version = (await res.json()).version ?? "?";
+            }
+        }
+        catch (err) {
+            throw new Error(this.api === "openai"
+                ? `The OpenAI-compatible endpoint at ${this.host} is not reachable or rejected the key (${msgOf(err)}).`
+                : `Ollama is not reachable at ${this.host} (${msgOf(err)}). Start it with \`ollama serve\` (install: https://ollama.com/download) and pull a tool-calling model, e.g. \`ollama pull ${this.model}\`.`);
+        }
+        await this.connectTools();
+        this.prepared = true;
+        logger.info(`[ollama-backend] ready (${this.api === "openai" ? `openai-compatible @ ${this.host}` : `ollama ${version}`}, model ${this.model}, ${this.comfyTools.length} comfyui meta-tools, ${this.panelTools.length} panel tools behind the router)`);
+    }
+    async connectTools() {
+        if (this.deps.connectToolClients) {
+            const { comfyui, panel } = await this.deps.connectToolClients();
+            this.comfy = comfyui ?? null;
+            this.panel = panel ?? null;
+        }
+        else if (this.deps.mcpServers) {
+            const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+            for (const [name, spec] of Object.entries(this.deps.mcpServers)) {
+                try {
+                    const client = new Client({ name: `ollama-backend-${name}`, version: "0.0.0" });
+                    if (spec.transport === "stdio") {
+                        const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+                        await client.connect(new StdioClientTransport({
+                            command: spec.command,
+                            args: spec.args ?? [],
+                            // Compact mode: the subprocess itself exposes the 3 meta-tools.
+                            env: { ...process.env, ...spec.env, COMFYUI_MCP_TOOL_MODE: "compact" },
+                        }));
+                        this.comfy = client;
+                    }
+                    else {
+                        const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+                        await client.connect(new StreamableHTTPClientTransport(new URL(spec.url)));
+                        this.panel = client;
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[ollama-backend] could not connect MCP server '${name}': ${msgOf(err)}`);
+                }
+            }
+        }
+        if (this.comfy)
+            this.comfyTools = (await this.comfy.listTools()).tools;
+        if (this.panel)
+            this.panelTools = (await this.panel.listTools()).tools;
+    }
+    /** The six OpenAI-style tool defs the model sees. */
+    buildModelTools() {
+        const defs = [];
+        for (const t of this.comfyTools) {
+            defs.push({
+                type: "function",
+                function: { name: t.name, description: t.description ?? "", parameters: t.inputSchema ?? { type: "object", properties: {} } },
+            });
+        }
+        if (this.panel && this.panelTools.length) {
+            defs.push({
+                type: "function",
+                function: {
+                    name: "panel_list_tools",
+                    description: "List the live-canvas panel tools (the user's open ComfyUI graph): names + one-line summaries. Use panel_describe_tool then panel_call_tool to run one.",
+                    parameters: {
+                        type: "object",
+                        properties: { search: { type: "string", description: "Case-insensitive substring filter." } },
+                    },
+                },
+            }, {
+                type: "function",
+                function: {
+                    name: "panel_describe_tool",
+                    description: "Full description and JSON Schema for one panel tool.",
+                    parameters: {
+                        type: "object",
+                        properties: { name: { type: "string", description: "Exact panel tool name." } },
+                        required: ["name"],
+                    },
+                },
+            }, {
+                type: "function",
+                function: {
+                    name: "panel_call_tool",
+                    description: "Run a panel tool by name with args matching its panel_describe_tool schema.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string", description: "Exact panel tool name." },
+                            args: { description: "The tool's parameters as an object (JSON-encoded string also accepted)." },
+                        },
+                        required: ["name"],
+                    },
+                },
+            });
+        }
+        return defs;
+    }
+    /** Dispatch one model tool call; returns display text (never throws). */
+    async dispatch(name, rawArgs) {
+        let args = {};
+        if (typeof rawArgs === "string") {
+            try {
+                args = rawArgs.trim() ? JSON.parse(rawArgs) : {};
+            }
+            catch {
+                return { text: `arguments were not valid JSON: ${rawArgs.slice(0, 200)}`, isError: true };
+            }
+        }
+        else if (rawArgs && typeof rawArgs === "object") {
+            args = rawArgs;
+        }
+        try {
+            if (this.comfyTools.some((t) => t.name === name)) {
+                if (!this.comfy)
+                    return { text: "comfyui tools are unavailable in this session.", isError: true };
+                const res = await this.comfy.callTool({ name, arguments: args });
+                return { text: textOf(res), isError: !!res.isError };
+            }
+            if (name === "panel_list_tools") {
+                const search = typeof args.search === "string" ? args.search.toLowerCase() : "";
+                const matching = search
+                    ? this.panelTools.filter((t) => t.name.toLowerCase().includes(search) || (t.description ?? "").toLowerCase().includes(search))
+                    : this.panelTools;
+                if (!matching.length)
+                    return { text: `No panel tools matched '${search}'. Call panel_list_tools with no filter to see all ${this.panelTools.length}.`, isError: false };
+                const lines = matching.map((t) => `- ${t.name}: ${firstSentence(t.description ?? "")}`);
+                return {
+                    text: `Live-canvas panel tools — ${matching.length} of ${this.panelTools.length}. Next: panel_describe_tool {"name": ...} then panel_call_tool.\n${lines.join("\n")}`,
+                    isError: false,
+                };
+            }
+            if (name === "panel_describe_tool") {
+                const wanted = typeof args.name === "string" ? args.name : "";
+                const tool = this.panelTools.find((t) => t.name === wanted);
+                if (!tool) {
+                    const close = this.panelTools.filter((t) => t.name.includes(wanted)).slice(0, 5).map((t) => t.name);
+                    return { text: `Unknown panel tool '${wanted}'.${close.length ? ` Did you mean: ${close.join(", ")}?` : ""} Use panel_list_tools.`, isError: true };
+                }
+                return {
+                    text: `# ${tool.name}\n\n${tool.description ?? ""}\n\nParameters (JSON Schema):\n${JSON.stringify(tool.inputSchema ?? {}, null, 1)}\n\nRun it with: panel_call_tool {"name": "${tool.name}", "args": {...}}`,
+                    isError: false,
+                };
+            }
+            if (name === "panel_call_tool") {
+                if (!this.panel)
+                    return { text: "panel tools are unavailable in this session.", isError: true };
+                const wanted = typeof args.name === "string" ? args.name : typeof args.tool_name === "string" ? args.tool_name : "";
+                if (!this.panelTools.some((t) => t.name === wanted)) {
+                    return { text: `Unknown panel tool '${wanted}'. Use panel_list_tools.`, isError: true };
+                }
+                let inner = args.args ?? args.arguments ?? {};
+                if (typeof inner === "string") {
+                    try {
+                        inner = inner.trim() ? JSON.parse(inner) : {};
+                    }
+                    catch {
+                        return { text: `args was not valid JSON: ${inner.slice(0, 200)}`, isError: true };
+                    }
+                }
+                if (inner === null || typeof inner !== "object" || Array.isArray(inner)) {
+                    return { text: `args must be a JSON object. See panel_describe_tool {"name": "${wanted}"}.`, isError: true };
+                }
+                const res = await this.panel.callTool({ name: wanted, arguments: inner });
+                if (res.isError) {
+                    logger.warn(`[ollama-backend] panel tool '${wanted}' returned isError: ${textOf(res).slice(0, 300)}`);
+                }
+                return { text: textOf(res), isError: !!res.isError };
+            }
+            // FORGIVING DIRECT DISPATCH — small models routinely call an inner tool
+            // by its bare name instead of going through the router. If the name is a
+            // real panel tool, run it on the panel client; anything else is handed to
+            // the compact server's call_tool, whose unknown-name error carries
+            // close-match suggestions the model can recover from.
+            if (this.panel && this.panelTools.some((t) => t.name === name)) {
+                const res = await this.panel.callTool({ name, arguments: args });
+                return { text: textOf(res), isError: !!res.isError };
+            }
+            if (this.comfy && this.comfyTools.some((t) => t.name === "call_tool")) {
+                const res = await this.comfy.callTool({ name: "call_tool", arguments: { name, args } });
+                return { text: textOf(res), isError: !!res.isError };
+            }
+            const known = [...this.comfyTools.map((t) => t.name), "panel_list_tools", "panel_describe_tool", "panel_call_tool"];
+            return { text: `Unknown tool '${name}'. Available: ${known.join(", ")}.`, isError: true };
+        }
+        catch (err) {
+            logger.warn(`[ollama-backend] tool '${name}' dispatch failed: ${msgOf(err)}`);
+            return { text: `Tool '${name}' failed: ${msgOf(err)}`, isError: true };
+        }
+    }
+    /** One /api/chat request (streaming). YIELDS delta events as chunks arrive and
+     *  RETURNS the accumulated assistant message + usage (read via iterator.next()
+     *  in runTurn so deltas stream through run() live). */
+    async *chatStream(messages, tools, signal, onActivity) {
+        // Keep the turn watchdog armed while the request is pending: a cold model
+        // load can sit 30s+ before the first byte — the provider is alive (the
+        // HTTP request is in flight), it's just loading weights into VRAM.
+        const keepalive = onActivity ? setInterval(onActivity, 5000) : null;
+        let res;
+        try {
+            res =
+                this.api === "openai"
+                    ? await fetch(`${this.host}/chat/completions`, {
+                        method: "POST",
+                        headers: { "content-type": "application/json", ...this.authHeaders() },
+                        body: JSON.stringify({
+                            model: this.model,
+                            messages: toOpenAiMessages(messages),
+                            tools,
+                            tool_choice: "auto",
+                            stream: true,
+                            stream_options: { include_usage: true },
+                            // Cap the output reservation: without it some models default to
+                            // 65k, which both invites runaways and 402s on low prepaid
+                            // balances (the request reserves credits for max_tokens).
+                            max_tokens: Number(process.env.COMFYUI_MCP_OLLAMA_MAX_TOKENS) || 8192,
+                        }),
+                        signal,
+                    })
+                    : await fetch(`${this.host}/api/chat`, {
+                        method: "POST",
+                        headers: { "content-type": "application/json" },
+                        body: JSON.stringify({
+                            model: this.model,
+                            messages,
+                            tools,
+                            stream: true,
+                            options: { num_ctx: this.deps.numCtx ?? 16384 },
+                        }),
+                        signal,
+                    });
+        }
+        finally {
+            if (keepalive)
+                clearInterval(keepalive);
+        }
+        if (!res.ok || !res.body) {
+            throw new Error(`${this.api === "openai" ? `${this.host}/chat/completions` : "ollama /api/chat"} http ${res.status}: ${(await res.text().catch(() => "")).slice(0, 300)}`);
+        }
+        if (this.api === "openai") {
+            return yield* this.readOpenAiSse(res.body, onActivity);
+        }
+        let content = "";
+        const toolCalls = [];
+        let usage;
+        let streamOpen = false;
+        const streamId = randomUUID();
+        let buffer = "";
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            onActivity?.();
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!line)
+                    continue;
+                let chunk;
+                try {
+                    chunk = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (chunk.error)
+                    throw new Error(`ollama: ${chunk.error}`);
+                const delta = chunk.message?.content ?? "";
+                if (delta) {
+                    if (!streamOpen) {
+                        streamOpen = true;
+                        yield { type: "stream_start", id: streamId };
+                    }
+                    content += delta;
+                    yield { type: "assistant_delta", text: delta };
+                }
+                if (chunk.message?.thinking) {
+                    // thinking deltas need an open bubble too (think-window rendering)
+                    if (!streamOpen) {
+                        streamOpen = true;
+                        yield { type: "stream_start", id: streamId };
+                    }
+                    yield { type: "assistant_delta", text: chunk.message.thinking, thinking: true };
+                }
+                if (chunk.message?.tool_calls?.length)
+                    toolCalls.push(...chunk.message.tool_calls);
+                if (chunk.done) {
+                    usage = {
+                        input_tokens: chunk.prompt_eval_count ?? 0,
+                        output_tokens: chunk.eval_count ?? 0,
+                    };
+                }
+            }
+        }
+        if (streamOpen)
+            yield { type: "stream_end" };
+        // streamId is returned only when a bubble was opened, so the assistant
+        // COMMIT can carry the same id — that reconciliation is what lets the
+        // panel replace the plain-text live bubble with the markdown-rendered
+        // message. A missing id left the raw text on screen (no markdown).
+        return { content, toolCalls, usage, streamId: streamOpen ? streamId : null };
+    }
+    /** OpenAI-compatible SSE reader: `data:` lines with choices[0].delta.
+     *  Tool calls stream as FRAGMENTS keyed by index (name once, arguments as
+     *  string chunks) — accumulate them into whole calls. */
+    async *readOpenAiSse(body, onActivity) {
+        let content = "";
+        let usage;
+        let streamOpen = false;
+        const streamId = randomUUID();
+        const partial = new Map();
+        let buffer = "";
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            onActivity?.();
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!line.startsWith("data:"))
+                    continue;
+                const payload = line.slice(5).trim();
+                if (!payload || payload === "[DONE]")
+                    continue;
+                let chunk;
+                try {
+                    chunk = JSON.parse(payload);
+                }
+                catch {
+                    continue;
+                }
+                if (chunk.error?.message)
+                    throw new Error(`endpoint: ${chunk.error.message}`);
+                const delta = chunk.choices?.[0]?.delta;
+                if (delta?.content) {
+                    if (!streamOpen) {
+                        streamOpen = true;
+                        yield { type: "stream_start", id: streamId };
+                    }
+                    content += delta.content;
+                    yield { type: "assistant_delta", text: delta.content };
+                }
+                if (delta?.reasoning) {
+                    if (!streamOpen) {
+                        streamOpen = true;
+                        yield { type: "stream_start", id: streamId };
+                    }
+                    yield { type: "assistant_delta", text: delta.reasoning, thinking: true };
+                }
+                for (const tc of delta?.tool_calls ?? []) {
+                    const idx = tc.index ?? 0;
+                    const slot = partial.get(idx) ?? { id: undefined, name: "", args: "" };
+                    if (tc.id)
+                        slot.id = tc.id;
+                    if (tc.function?.name)
+                        slot.name = tc.function.name;
+                    if (tc.function?.arguments)
+                        slot.args += tc.function.arguments;
+                    partial.set(idx, slot);
+                }
+                if (chunk.usage) {
+                    usage = {
+                        input_tokens: chunk.usage.prompt_tokens ?? 0,
+                        output_tokens: chunk.usage.completion_tokens ?? 0,
+                    };
+                }
+            }
+        }
+        if (streamOpen)
+            yield { type: "stream_end" };
+        const toolCalls = [...partial.entries()]
+            .sort((a, b) => a[0] - b[0])
+            .map(([i, s]) => ({ id: s.id ?? `call_${i}`, function: { name: s.name, arguments: s.args || "{}" } }));
+        return { content, toolCalls, usage, streamId: streamOpen ? streamId : null };
+    }
+    async *run(opts) {
+        await this.prepare();
+        if (opts.model && isOllamaModel(opts.model))
+            this.model = opts.model;
+        // Ollama is stateless — "session" is our in-memory history. A resume id is
+        // honored in name (the panel replays the transcript as context anyway).
+        const fresh = !this.sessionId || (opts.resume && opts.resume !== this.sessionId);
+        this.sessionId = opts.resume ?? this.sessionId ?? `ollama-${randomUUID()}`;
+        if (fresh) {
+            // deps.systemAppend (the frontier panel prompt) is intentionally NOT
+            // used — see OLLAMA_SYSTEM_PROMPT.
+            this.history = [{ role: "system", content: OLLAMA_SYSTEM_PROMPT }];
+        }
+        yield { type: "session", sessionId: this.sessionId, model: this.model };
+        for await (const turn of opts.channel) {
+            yield* this.runTurn(turn, opts);
+        }
+    }
+    async *runTurn(turn, opts) {
+        const abort = new AbortController();
+        this.turnAbort = abort;
+        const tools = this.buildModelTools();
+        this.history.push({ role: "user", content: turn.text });
+        let resultEmitted = false;
+        try {
+            for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+                // Drain the chat stream manually: yield each delta event as it arrives,
+                // and capture the generator's RETURN value (the accumulated message).
+                const stream = this.chatStream(this.history, tools, abort.signal, opts.onActivity);
+                let content = "";
+                let toolCalls = [];
+                let usage;
+                let streamId = null;
+                for (;;) {
+                    const r = await stream.next();
+                    if (r.done) {
+                        ({ content, toolCalls, usage, streamId } = r.value);
+                        break;
+                    }
+                    yield r.value;
+                }
+                if (!toolCalls.length) {
+                    yield { type: "assistant", text: content, id: streamId ?? undefined, usage };
+                    yield { type: "result", ok: true, usage };
+                    resultEmitted = true;
+                    return;
+                }
+                this.history.push({ role: "assistant", content, tool_calls: toolCalls });
+                for (const [i, tc] of toolCalls.entries()) {
+                    if (abort.signal.aborted)
+                        throw new Error("interrupted");
+                    const name = tc.function?.name ?? "?";
+                    yield { type: "tool_call", name, phase: "start", detail: tc.function?.arguments };
+                    const { text, isError } = await this.dispatch(name, tc.function?.arguments ?? {});
+                    opts.onActivity?.();
+                    yield { type: "tool_call", name, phase: "end", detail: { isError } };
+                    this.history.push({
+                        role: "tool",
+                        tool_name: name,
+                        tool_call_id: tc.id ?? `call_${i}`,
+                        content: text.slice(0, 16000),
+                    });
+                }
+            }
+            // Round budget exhausted — commit what we have so the turn gate advances.
+            yield {
+                type: "assistant",
+                text: "(stopped: too many tool rounds in one turn — ask me to continue)",
+            };
+            yield { type: "result", ok: false, subtype: "max_tool_rounds" };
+            resultEmitted = true;
+        }
+        catch (err) {
+            const interrupted = abort.signal.aborted;
+            if (!interrupted) {
+                // Surface the failure IN the chat too — an error event alone leaves the
+                // panel silent (the turn just ends), which reads as a wedge.
+                logger.warn(`[ollama-backend] turn failed: ${msgOf(err)}`);
+                yield { type: "error", message: `ollama backend: ${msgOf(err)}` };
+                yield {
+                    type: "assistant",
+                    text: `⚠️ The model request failed: ${msgOf(err).slice(0, 400)}`,
+                };
+            }
+            if (!resultEmitted) {
+                yield { type: "result", ok: false, subtype: interrupted ? "interrupted" : "error" };
+            }
+        }
+        finally {
+            if (this.turnAbort === abort)
+                this.turnAbort = null;
+        }
+    }
+    async interrupt() {
+        this.turnAbort?.abort();
+    }
+    async setModel(model) {
+        // Ollama picks the model per request — a live switch is just bookkeeping.
+        if (isOllamaModel(model))
+            this.model = model;
+    }
+    async listModels() {
+        try {
+            if (this.api === "openai") {
+                const res = await fetch(`${this.host}/models`, {
+                    headers: this.authHeaders(),
+                    signal: AbortSignal.timeout(8000),
+                });
+                if (!res.ok)
+                    return [{ id: this.model, label: this.model }];
+                const data = (await res.json());
+                const ids = (data.data ?? []).map((m) => m.id).filter((n) => !!n);
+                // Hosted catalogs can be huge (OpenRouter: 300+). Surface the configured
+                // model first, then a bounded slice — the panel picker isn't a browser.
+                const rest = ids.filter((id) => id !== this.model).slice(0, 40);
+                return [this.model, ...rest].map((id) => ({ id, label: id }));
+            }
+            const res = await fetch(`${this.host}/api/tags`, { signal: AbortSignal.timeout(5000) });
+            if (!res.ok)
+                return [];
+            const data = (await res.json());
+            return (data.models ?? [])
+                .map((m) => m.name)
+                .filter((n) => !!n)
+                .map((id) => ({ id, label: id }));
+        }
+        catch {
+            return this.api === "openai" ? [{ id: this.model, label: this.model }] : [];
+        }
+    }
+    async close() {
+        this.disposed = true;
+        this.turnAbort?.abort();
+        await this.comfy?.close().catch(() => { });
+        await this.panel?.close().catch(() => { });
+        this.comfy = null;
+        this.panel = null;
+        this.prepared = false;
+    }
+}
+//# sourceMappingURL=ollama-backend.js.map