comfyui-mcp 0.52.13 → 0.52.15

package/dist/orchestrator/qwen-backend.js

@@ -0,0 +1,1029 @@
+// Qwen Code backend — the provider-specific adapter behind the AgentBackend
+// port, driving the Qwen Code CLI over its **ACP (Agent Client Protocol)** mode
+// (`qwen --acp`), a JSON-RPC 2.0 client over stdio. This is a faithful MIRROR
+// of gemini-backend.ts: same self-contained line-framed JSON-RPC client, same
+// per-turn event-queue bridge, same terminal-result invariant, same
+// Windows/POSIX process-tree kill. Qwen Code was forked from the Gemini CLI, so
+// its ACP surface (`initialize` → `session/new` → `session/prompt`, streamed
+// `session/update` notifications, `session/cancel`) is the same protocol.
+//
+// PanelAgent keeps all provider-agnostic orchestration (queue, turn-gate, bridge
+// push, self-restart) and drives this backend via
+// `for await (const ev of backend.run({...}))`. See
+// design/agent-backend-injection.md.
+//
+// TRANSPORT CHOICE (issue #1417): Qwen Code ALSO ships an experimental
+// `qwen serve` HTTP/SSE daemon whose northbound API multiplexes ONE agent across
+// many clients — and which itself speaks ACP to a spawned `qwen --acp` child.
+// The Agent Panel wants exactly the opposite (one orchestrator-scoped session
+// per tab), so this backend takes the stdio `qwen --acp` path directly and the
+// daemon is deliberately NOT used (no daemon lifecycle, no SSE replay layer, no
+// bearer-auth surface — `qwen serve` is the transport Qwen itself marks
+// experimental).
+//
+// AUTH (the CLI owns auth): Qwen Code authenticates via `qwen` → `/auth`
+// (Alibaba ModelStudio Coding Plan, third-party providers, or a custom
+// OpenAI/Anthropic/Gemini-compatible endpoint), persisted in
+// ~/.qwen/settings.json, or via env keys (DASHSCOPE_API_KEY,
+// BAILIAN_CODING_PLAN_API_KEY, OPENAI_API_KEY/OPENAI_BASE_URL) — all forwarded
+// through the spawned process.env. The Qwen OAuth free tier was DISCONTINUED
+// 2026-04-15, so a CLI that was previously signed in can carry a stale
+// `qwen-oauth` selectedType + dead cached creds that OUTRANK a valid env key
+// (session/new succeeds, the first prompt then dies) — the exact trap the
+// Gemini backend hit with the retired Google individual login. We therefore
+// authenticate PROACTIVELY with the `openai` auth method when an env key is set
+// (see pickAuthMethod), and otherwise react to an `auth_required` error from
+// session/new with a single `authenticate` retry, surfacing an actionable
+// sign-in message if it still fails.
+//
+// PARITY with Codex/Gemini: the Qwen backend gets the SAME tool surface — the
+// headless `comfyui` stdio MCP plus the `panel` HTTP MCP for live-graph panel_*
+// tools — declared to `session/new` as ACP McpServers. The panel system prompt
+// is prepended to the FIRST turn's prompt (ACP `session/new` has no system /
+// instructions field).
+//
+// WINDOWS: Qwen Code is commonly installed as `qwen.cmd`, which Node cannot
+// spawn shell-lessly — so on win32 we spawn through the shell (mirroring the
+// Gemini PATH fallback) and close() kills the whole process TREE (the direct
+// child is the cmd shim, the grandchild the real qwen node process).
+//
+// ASSUMPTIONS we could NOT verify without the live `qwen` CLI (flagged inline,
+// see also the PR body): the exact ACP McpServer http/sse variant shape (we
+// reuse the `sse` mapping the live Gemini/Grok CLIs require), the session/load
+// resume semantics, the auth_required retry, and live model switching (the
+// model is set at SPAWN via --model since ACP exposes no standard per-session
+// model setter). Each is the closest faithful mapping to the documented ACP
+// spec.
+import { spawn, spawnSync } from "node:child_process";
+import readline from "node:readline";
+import { logger } from "../utils/logger.js";
+import { errorText, promptText } from "./error-text.js";
+import { buildAgentSpawnEnv } from "../services/panel-secrets.js";
+import { QWEN_CAPABILITIES, stampTurn, } from "./agent-backend.js";
+function msgOf(err) {
+    return errorText(err);
+}
+/**
+ * Kill an entire process tree, not just the direct child. On the Windows
+ * PATH/shell fallback the direct child is a cmd.exe/`.cmd` shim whose grandchild
+ * is the real `qwen` node process — killing only the shell leaves the tree
+ * alive. Use `taskkill /T /F`. On POSIX, signal the process group (negative pid)
+ * so a shell + its child both die, falling back to the single pid. Best-effort +
+ * swallows errors: it runs during teardown and must never throw into the host.
+ * (Identical to gemini-backend's killProcessTree — same spawn posture.)
+ */
+function killProcessTree(pid) {
+    if (!Number.isFinite(pid))
+        return;
+    const p = pid;
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/PID", String(p), "/T", "/F"], { windowsHide: true });
+        }
+        catch {
+            try {
+                process.kill(p);
+            }
+            catch {
+                // already gone
+            }
+        }
+        return;
+    }
+    try {
+        process.kill(-p, "SIGTERM"); // process group (we spawn detached on POSIX)
+    }
+    catch {
+        try {
+            process.kill(p, "SIGTERM");
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+/** An Error carrying the JSON-RPC error `data` so the auth_required reason
+ *  survives the request rejection (used to drive the authenticate retry). */
+class RpcError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+class AcpClient {
+    cmd;
+    args;
+    cwd;
+    env;
+    useShell;
+    proc = null;
+    rl = null;
+    pending = new Map();
+    nextId = 1;
+    closed = false;
+    exitResolved = false;
+    /** The error that ended the connection (null = clean exit). */
+    exitError = null;
+    stderr = "";
+    notificationHandler = null;
+    resolveExit;
+    /** Resolves when the `qwen` process exits or errors — runTurn() races its
+     *  per-turn drain against this so a child that dies mid-prompt never deadlocks
+     *  the turn forever (mirrors codex P0-2). */
+    exitPromise;
+    constructor(cmd, args, cwd, env, useShell) {
+        this.cmd = cmd;
+        this.args = args;
+        this.cwd = cwd;
+        this.env = env;
+        this.useShell = useShell;
+        this.exitPromise = new Promise((resolve) => {
+            this.resolveExit = resolve;
+        });
+    }
+    /** Spawn `qwen --acp` and perform the ACP `initialize` handshake. Returns the
+     *  agent's initialize result (capabilities + authMethods). NOTE: ACP has NO
+     *  `initialized` notification (that's MCP, not ACP) — initialize is a plain
+     *  request/response, after which we go straight to session/new. */
+    async initialize(clientInfo) {
+        this.proc = spawn(this.cmd, this.args, {
+            cwd: this.cwd,
+            env: this.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            shell: this.useShell,
+            // POSIX: own process group so close() can kill the whole tree with one
+            // negative-pid signal. Windows uses taskkill /T instead.
+            detached: process.platform !== "win32",
+        });
+        this.proc.stdout.setEncoding("utf8");
+        this.proc.stderr.setEncoding("utf8");
+        this.proc.stderr.on("data", (chunk) => {
+            this.stderr += chunk;
+        });
+        // Route pipe errors (EPIPE when the child dies mid-turn) through handleExit so
+        // the turn rejects cleanly instead of crashing the host as an uncaught error.
+        this.proc.stdin.on("error", (error) => this.handleExit(error));
+        this.proc.stdout.on("error", (error) => this.handleExit(error));
+        this.proc.on("error", (error) => this.handleExit(error));
+        this.proc.on("exit", (code, signal) => {
+            const detail = code === 0
+                ? null
+                : new Error(`qwen --acp exited unexpectedly (${signal ? `signal ${signal}` : `exit ${code}`}).${this.stderr ? ` ${this.stderr.trim().split(/\r?\n/).slice(-2).join(" ")}` : ""}`);
+            this.handleExit(detail);
+        });
+        this.rl = readline.createInterface({ input: this.proc.stdout });
+        this.rl.on("line", (line) => this.handleLine(line));
+        // ACP initialize: negotiate protocol version + advertise client capabilities.
+        // We do NOT implement the client fs/terminal methods, so advertise them false
+        // (the agent then won't issue fs/read_text_file, terminal/*, etc.).
+        const result = await this.request("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false,
+            },
+            clientInfo,
+        });
+        return result;
+    }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error("qwen --acp client is closed."));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject, method });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params = {}) {
+        if (this.closed)
+            return;
+        // Fire-and-forget: a write failure (dead child) must not throw into the caller.
+        try {
+            this.send({ method, params });
+        }
+        catch {
+            // connection gone; pending requests already rejected via handleExit
+        }
+    }
+    send(message) {
+        const stdin = this.proc?.stdin;
+        if (!stdin || stdin.destroyed || stdin.writableEnded) {
+            this.handleExit(this.exitError ?? new Error("qwen --acp stdin is not available."));
+            throw this.exitError ?? new Error("qwen --acp stdin is not available.");
+        }
+        // ACP is strict JSON-RPC 2.0 — every outbound frame carries `jsonrpc:"2.0"`.
+        const framed = { jsonrpc: "2.0", ...message };
+        try {
+            stdin.write(`${JSON.stringify(framed)}\n`);
+        }
+        catch (err) {
+            this.handleExit(err instanceof Error ? err : new Error(String(err)));
+            throw err;
+        }
+    }
+    /**
+     * The auto-approve RESULT for a server→client request, or null if it isn't one
+     * we should auto-grant. The panel agent is an ISOLATED background agent (same
+     * posture as Claude's bypassPermissions / Codex's auto-approve), so we grant
+     * tool-permission requests to keep the live-graph work flowing.
+     *
+     * ACP permission flow: the agent sends `session/request_permission`
+     * ({ sessionId, toolCall, options:[{ optionId, name, kind }] }) and expects
+     * { outcome: { outcome:"selected", optionId } }. We pick the most-permissive
+     * "allow" option (allow_always > allow_once); if none is offered we cancel.
+     */
+    autoApproveResult(msg) {
+        if (msg.method !== "session/request_permission")
+            return null;
+        const params = (msg.params ?? {});
+        const options = Array.isArray(params.options) ? params.options : [];
+        const pick = options.find((o) => o.kind === "allow_always") ??
+            options.find((o) => o.kind === "allow_once") ??
+            // Fall back to any option whose id/kind reads as an allow.
+            options.find((o) => /allow/i.test(o.kind ?? "") || /allow/i.test(o.optionId ?? ""));
+        if (pick?.optionId) {
+            return { outcome: { outcome: "selected", optionId: pick.optionId } };
+        }
+        // No allow option offered → decline gracefully so the agent moves on.
+        return { outcome: { outcome: "cancelled" } };
+    }
+    handleLine(line) {
+        if (!line.trim())
+            return;
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch (error) {
+            this.handleExit(new Error(`Failed to parse qwen --acp JSONL: ${msgOf(error)}`));
+            return;
+        }
+        // Server→client request (id + method). Auto-approve permission prompts; reply
+        // method-not-found to anything else so the protocol keeps moving (we declared
+        // no fs/terminal client capabilities, so those shouldn't arrive).
+        if (message.id !== undefined && message.method) {
+            const result = this.autoApproveResult(message);
+            if (result) {
+                logger.debug(`[qwen-backend] auto-approving server request ${message.method}`);
+                this.send({ id: message.id, result });
+            }
+            else {
+                logger.debug(`[qwen-backend] unsupported server request ${message.method} — replying method-not-found`);
+                this.send({
+                    id: message.id,
+                    error: { code: -32601, message: `Unsupported server request: ${message.method}` },
+                });
+            }
+            return;
+        }
+        // Response to one of our requests.
+        if (message.id !== undefined) {
+            const p = this.pending.get(message.id);
+            if (!p)
+                return;
+            this.pending.delete(message.id);
+            if (message.error) {
+                p.reject(new RpcError(message.error.message ?? `qwen --acp ${p.method} failed.`, message.error.code, message.error.data));
+            }
+            else {
+                p.resolve(message.result ?? {});
+            }
+            return;
+        }
+        // Notification.
+        if (message.method)
+            this.notificationHandler?.(message);
+    }
+    handleExit(error) {
+        if (this.exitResolved)
+            return;
+        this.exitResolved = true;
+        this.exitError = error;
+        for (const p of this.pending.values())
+            p.reject(error ?? new Error("qwen --acp connection closed."));
+        this.pending.clear();
+        this.resolveExit();
+    }
+    async close() {
+        if (this.closed) {
+            await this.exitPromise;
+            return;
+        }
+        this.closed = true;
+        this.notificationHandler = null;
+        this.rl?.close();
+        this.rl = null;
+        if (this.proc && this.proc.exitCode === null) {
+            try {
+                this.proc.stdin.end();
+            }
+            catch {
+                // already gone
+            }
+            const proc = this.proc;
+            // Give a graceful stdin-EOF shutdown a beat, then KILL THE WHOLE TREE — on
+            // the Windows shell fallback the direct child is a shim whose grandchild is
+            // the real qwen node process, so proc.kill() alone would orphan it.
+            setTimeout(() => {
+                if (proc.exitCode === null)
+                    killProcessTree(proc.pid);
+            }, 50).unref?.();
+        }
+        await this.exitPromise;
+        this.proc = null;
+    }
+}
+// ---- model catalog ----
+// ACP exposes no model enumeration, and the model is fixed at SPAWN via the CLI
+// `--model` flag — so we surface a static catalog of the current Qwen coding
+// family (the models the Alibaba ModelStudio Coding Plan advertises for
+// `qwen --model`, per qwenlm.github.io/qwen-code-docs). Qwen Code's own default
+// is qwen3-coder-plus; COMFYUI_MCP_QWEN_MODEL overrides, and any id the CLI
+// accepts (a custom modelProviders entry, e.g.) works the same way.
+const QWEN_MODELS = [
+    { id: "qwen3-coder-plus", label: "Qwen3 Coder Plus" },
+    { id: "qwen3-coder-next", label: "Qwen3 Coder Next" },
+    { id: "qwen3.7-plus", label: "Qwen3.7 Plus" },
+];
+const QWEN_DEFAULT_MODEL = "qwen3-coder-plus";
+/** Does this id look like a Qwen model (vs. the Claude panel model PanelAgent
+ *  unconditionally passes as opts.model)? Used so the configured Qwen model
+ *  wins — mirrors gemini-backend's isGeminiModel guard (P1-1). */
+function isQwenModel(id) {
+    // Qwen ids start with "qwen" with NO separator (qwen3-coder-plus, qwen3.7-plus).
+    return /^qwen/i.test(id);
+}
+/**
+ * Convert our MCP server specs into the ACP `session/new` `mcpServers` array.
+ * ACP stdio McpServer: { name, command, args, env:[{name,value}] }. Streamable
+ * HTTP MCP rides the SSE variant ({ type:"sse", name, url, headers:[] }) — the
+ * live Gemini (and Grok) CLIs reject { type:"http" } with Invalid params on the
+ * FIRST user message, after a successful connect ack, so the old "http" mapping
+ * made a panel-MCP-attached tab look connected but fail on first use.
+ * (Identical to gemini-backend's buildAcpMcpServers — same wire shape.)
+ */
+export function buildAcpMcpServers(servers) {
+    const out = [];
+    for (const [name, spec] of Object.entries(servers)) {
+        if (spec.transport === "stdio") {
+            out.push({
+                name,
+                command: spec.command,
+                args: spec.args ?? [],
+                env: Object.entries(spec.env ?? {}).map(([k, v]) => ({ name: k, value: v })),
+            });
+        }
+        else {
+            out.push({ type: "sse", name, url: spec.url, headers: [] });
+        }
+    }
+    return out;
+}
+/** The env keys that count as a Qwen-side credential for the auth flow: the
+ *  Dashscope standard key, the Coding Plan key, or a generic OpenAI-compatible
+ *  key (the CLI's `openai` auth type reads OPENAI_API_KEY/OPENAI_BASE_URL). */
+const QWEN_AUTH_ENV_KEYS = ["DASHSCOPE_API_KEY", "BAILIAN_CODING_PLAN_API_KEY", "OPENAI_API_KEY"];
+function qwenAuthKeyPresent() {
+    return QWEN_AUTH_ENV_KEYS.some((k) => !!process.env[k]?.trim());
+}
+/**
+ * The Qwen Code CLI ACP adapter. One instance per PanelAgent; it holds the live
+ * ACP client + current session id and re-opens on each `run()`.
+ */
+export class QwenBackend {
+    id = "qwen";
+    capabilities = QWEN_CAPABILITIES;
+    deps;
+    client = null;
+    /** The client an in-flight prepare() is spinning up, tracked so a concurrent
+     *  close() can tear it down before it's published (P0-A). */
+    preparingClient = null;
+    /** Set once close() runs — a tripwire so an in-flight prepare() disposes its
+     *  local client instead of publishing it (P0-A). */
+    disposed = false;
+    /** Cached resolved spawn command/args/shell (set in prepare()). */
+    spawnSpec = null;
+    /** The live ACP session id — used for session/prompt + session/cancel. */
+    sessionId = null;
+    /** The model requested for new sessions (applied at SPAWN via --model). */
+    model;
+    /** The model the LIVE `qwen --acp` child was actually spawned with. Qwen Code
+     *  pins the model at spawn, so when this drifts from `this.model` (a live
+     *  setModel) the run loop respawns the CLI before the next turn (P1). */
+    spawnedModel;
+    /** Capabilities the agent advertised at initialize (loadSession / image / http). */
+    agentCaps = undefined;
+    authMethods = [];
+    /** True until the panel system prompt has been prepended to a turn. Reset
+     *  whenever a NEW session starts (run()). */
+    needsSystemPreamble = false;
+    constructor(deps = {}) {
+        this.deps = deps;
+        this.model = deps.model;
+    }
+    /**
+     * Resolve how to spawn `qwen --acp`. Unlike Gemini there is NO bundled npm
+     * package in this repo — the Qwen Code CLI is a separate install
+     * (`npm i -g @qwen-code/qwen-code`, brew, or the standalone installer), so we
+     * resolve `qwen` from PATH. A PATH `qwen` on Windows resolves to a
+     * `.cmd`/`.ps1` shim, which spawn can't find WITHOUT a shell — hence
+     * useShell on win32 (mirrors gemini-backend's PATH fallback; the tree kill in
+     * close() handles the shim's grandchild). The `--model` flag pins the model
+     * at spawn (ACP has no standard per-session model setter).
+     */
+    resolveSpawn() {
+        if (this.spawnSpec)
+            return this.spawnSpec;
+        const modelArgs = this.model ? ["--model", this.model] : [];
+        this.spawnSpec = {
+            cmd: "qwen",
+            args: ["--acp", ...modelArgs],
+            useShell: process.platform === "win32",
+        };
+        return this.spawnSpec;
+    }
+    /**
+     * Fetch a ComfyUI image (/view) and return it as an ACP base64 `image`
+     * ContentBlock ({ type:"image", mimeType, data }) — or null on any failure (the
+     * text reference still names the image as a fallback). ACP takes inline base64,
+     * so this mirrors GeminiBackend.fetchImageBlock exactly.
+     */
+    async fetchImageBlock(ref) {
+        if (!this.deps.comfyuiUrl || !ref?.filename)
+            return null;
+        try {
+            const u = new URL("/view", this.deps.comfyuiUrl);
+            u.searchParams.set("filename", ref.filename);
+            u.searchParams.set("type", ref.type || "input");
+            if (ref.subfolder)
+                u.searchParams.set("subfolder", ref.subfolder);
+            const res = await fetch(u, { signal: AbortSignal.timeout(15000) });
+            if (!res.ok)
+                return null;
+            let mt = (res.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
+            if (!["image/png", "image/jpeg", "image/gif", "image/webp"].includes(mt)) {
+                mt = "image/png"; // ComfyUI outputs are PNG by default
+            }
+            const buf = Buffer.from(await res.arrayBuffer());
+            if (buf.length > 12 * 1024 * 1024)
+                return null; // keep context sane (parity with Claude)
+            return { type: "image", mimeType: mt, data: buf.toString("base64") };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Preflight: resolve + spawn `qwen --acp` and perform the ACP `initialize`
+     * handshake. Fails fast with a clear reject so a missing binary surfaces
+     * immediately instead of being retried as a dropped session. Idempotent —
+     * reuses the live client. NOTE: the actual login is verified lazily at
+     * `session/new` (ACP returns auth_required there) — see ensureSession() —
+     * since ACP has no pre-session account probe; flagged in the PR body.
+     */
+    async prepare() {
+        if (this.disposed)
+            throw new Error("qwen backend is closed.");
+        if (this.client)
+            return;
+        const { cmd, args, useShell } = this.resolveSpawn();
+        const cwd = this.deps.cwd ?? process.cwd();
+        // SECURITY: spawn with the agent env — process.env MINUS tool-only secrets
+        // (RunPod/HF/CivitAI… tokens; they belong only to the comfyui tool child).
+        // The Qwen auth env keys (DASHSCOPE_API_KEY & co.) are NOT tool-only, so
+        // they pass through unchanged — they are this provider's OWN credential.
+        const client = new AcpClient(cmd, args, cwd, buildAgentSpawnEnv(process.env), useShell);
+        // Publish the in-flight client BEFORE the startup awaits so a concurrent
+        // close() can find and kill it (P0-A).
+        this.preparingClient = client;
+        const abortIfDisposed = async () => {
+            if (!this.disposed)
+                return;
+            if (this.preparingClient === client)
+                this.preparingClient = null;
+            await client.close().catch(() => { });
+            throw new Error("qwen backend was closed during prepare().");
+        };
+        try {
+            let init;
+            try {
+                init = await client.initialize({
+                    name: "comfyui-mcp",
+                    title: "comfyui-mcp panel",
+                    version: "0.16.0",
+                });
+            }
+            catch (err) {
+                await client.close().catch(() => { });
+                throw new Error(`Could not start the Qwen Code CLI in ACP mode (qwen backend). Install Qwen Code (npm i -g @qwen-code/qwen-code, or ensure \`qwen\` is on PATH) and sign in (run \`qwen\` once and complete /auth, or set DASHSCOPE_API_KEY / BAILIAN_CODING_PLAN_API_KEY). Details: ${msgOf(err)}`);
+            }
+            await abortIfDisposed();
+            this.agentCaps = init.agentCapabilities;
+            this.authMethods = Array.isArray(init.authMethods) ? init.authMethods : [];
+            this.client = client;
+            // Record what the live child was spawned with so a later setModel can detect
+            // the model drifted and respawn (the model is spawn-pinned via --model) (P1).
+            this.spawnedModel = this.model;
+            logger.info(`[qwen-backend] ACP ready (protocol ${init.protocolVersion ?? "?"}, agent ${init.agentInfo?.name ?? "qwen"}${this.authMethods.length ? `, ${this.authMethods.length} auth method(s)` : ""})`);
+        }
+        finally {
+            if (this.preparingClient === client)
+                this.preparingClient = null;
+        }
+    }
+    /** Ensure a live ACP session exists, creating (session/new) or resuming
+     *  (session/load) one. Handles an `auth_required` error from session/new by
+     *  attempting a single `authenticate` with the picked method (see
+     *  pickAuthMethod), then retrying — surfacing a clear sign-in message if it
+     *  still fails. Returns the session id. */
+    async ensureSession(client, cwd, resumeId) {
+        const mcpServers = this.deps.mcpServers ? buildAcpMcpServers(this.deps.mcpServers) : [];
+        const canLoad = this.agentCaps?.loadSession === true;
+        // RESUME (session/load) — whole-session only (forkAtAnchor=false). Only if the
+        // agent advertised loadSession; otherwise fall through to a fresh session.
+        if (resumeId && canLoad) {
+            try {
+                await client.request("session/load", { sessionId: resumeId, cwd, mcpServers });
+                this.sessionId = resumeId;
+                this.needsSystemPreamble = false; // persona already delivered on the original first turn
+                return resumeId;
+            }
+            catch (err) {
+                logger.warn(`[qwen-backend] session/load failed (${msgOf(err)}) — starting a fresh session`);
+            }
+        }
+        // NEW session, with one auth_required retry.
+        const createNew = async () => {
+            const res = await client.request("session/new", { cwd, mcpServers });
+            if (!res?.sessionId)
+                throw new Error("qwen --acp session/new returned no sessionId.");
+            return res.sessionId;
+        };
+        // PROACTIVE API-key auth. When a Qwen-side env key is set we authenticate up
+        // front rather than only reacting to `auth_required`. Why: a CLI that was
+        // previously signed in via Qwen OAuth keeps `security.auth.selectedType:
+        // "qwen-oauth"` + cached OAuth creds, which OUTRANK the env key — and the
+        // Qwen OAuth free tier was discontinued 2026-04-15, so `session/new` can
+        // SUCCEED via the dead OAuth without ever raising `auth_required`, then fail
+        // at request time. Authenticating with the openai method here switches the
+        // CLI onto the env key and clears the stale creds (mirrors gemini-backend's
+        // GEMINI_API_KEY proactive auth after the 2026-06-18 Google login sunset).
+        if (qwenAuthKeyPresent()) {
+            const apiKeyMethod = this.pickAuthMethod();
+            if (apiKeyMethod) {
+                try {
+                    await client.request("authenticate", { methodId: apiKeyMethod });
+                }
+                catch (err) {
+                    logger.warn(`[qwen-backend] proactive API-key authenticate failed (${msgOf(err)}) — continuing to session/new`);
+                }
+            }
+        }
+        try {
+            this.sessionId = await createNew();
+        }
+        catch (err) {
+            if (!this.isAuthRequired(err))
+                throw err;
+            // The CLI owns auth. Pick the openai/api-key method when an env key is set
+            // rather than blindly the first advertised method; the key itself already
+            // reaches the CLI via the spawned process.env.
+            const methodId = this.pickAuthMethod();
+            if (!methodId)
+                throw new Error(this.authFailureMessage());
+            try {
+                await client.request("authenticate", { methodId });
+                this.sessionId = await createNew();
+            }
+            catch {
+                throw new Error(this.authFailureMessage());
+            }
+        }
+        this.needsSystemPreamble = !!this.deps.systemAppend; // fresh session → persona on first turn
+        return this.sessionId;
+    }
+    /** Choose the ACP auth method for the `authenticate` retry. Prefers the
+     *  openai / api-key method when a Qwen-side env key is set — blindly taking
+     *  authMethods[0] could pick the discontinued qwen-oauth flow, which
+     *  dead-loops headlessly. Falls back to the first advertised method when no
+     *  key is set or no api-key-ish method is advertised. We match against the
+     *  CLI's own advertised methods rather than hardcoding the literal, so this
+     *  survives auth-type value changes across qwen-code versions. */
+    pickAuthMethod() {
+        const methods = this.authMethods;
+        if (methods.length === 0)
+            return undefined;
+        if (qwenAuthKeyPresent()) {
+            const hay = (m) => `${m.id ?? ""} ${m.name ?? ""} ${m.description ?? ""}`.toLowerCase();
+            // Strong match: the canonical openai auth-type value (Qwen Code's
+            // OpenAI-compatible / Dashscope / Coding Plan path).
+            const strong = methods.find((m) => m.id === "openai" || m.id === "use_openai");
+            if (strong?.id)
+                return strong.id;
+            // Loose fallback: an api-key-ish method that is clearly NOT oauth.
+            const loose = methods.find((m) => {
+                const h = hay(m);
+                return /api.?key|openai|dashscope|coding.?plan/.test(h) && !/oauth|sign.?in|log.?in/.test(h);
+            });
+            if (loose?.id)
+                return loose.id;
+        }
+        return methods[0]?.id;
+    }
+    /** A clear sign-in error: points key-holders at a likely bad key, and everyone
+     *  else at the two supported sign-in paths (interactive /auth, or an env key). */
+    authFailureMessage() {
+        return qwenAuthKeyPresent()
+            ? "Qwen Code CLI rejected the API key. Ensure DASHSCOPE_API_KEY / BAILIAN_CODING_PLAN_API_KEY / " +
+                "OPENAI_API_KEY is valid (and OPENAI_BASE_URL points at the right endpoint for a Coding Plan key), " +
+                "then Disconnect → Connect to retry."
+            : "Qwen Code CLI is not authenticated. Run `qwen` once and complete /auth (Alibaba ModelStudio Coding " +
+                "Plan or a provider API key — the Qwen OAuth free tier ended 2026-04-15), or set DASHSCOPE_API_KEY " +
+                "in ~/.comfyui-mcp/.env, then Disconnect → Connect to retry.";
+    }
+    /** Does this error look like an ACP `auth_required`? Reads the JSON-RPC error
+     *  data.reason carried by RpcError, falling back to the message text. */
+    isAuthRequired(err) {
+        if (err instanceof RpcError) {
+            const data = err.data;
+            if (data?.reason === "auth_required")
+                return true;
+        }
+        return /auth.?required|authenticat|not.*(logged|signed).*in/i.test(msgOf(err));
+    }
+    /**
+     * Open/continue an ACP session and yield canonical AgentEvents. The user
+     * channel (PanelAgent's gated queue) is consumed ONE turn at a time: each
+     * neutral batch becomes a `session/prompt`, whose streamed session/update
+     * notifications are normalized to AgentEvents, and only after the prompt
+     * resolves (stopReason) do we read the next batch (the channel async-iteration
+     * IS the turn-gate).
+     */
+    async *run(opts) {
+        // MODEL PRECEDENCE (P1): apply the panel-selected model BEFORE prepare() so the
+        // FIRST spawn uses it (the model is spawn-pinned via `--model`; preparing first
+        // would spawn the wrong model). PanelAgent.start() usually passes opts.model =
+        // the CLAUDE panel model, which is NOT a valid Qwen model — so the configured
+        // Qwen model (deps.model, from COMFYUI_MCP_QWEN_MODEL) wins; only honor
+        // opts.model when it actually looks like a Qwen model (e.g. the user picked
+        // one in the panel, which arrives as opts.model on a fresh spawn).
+        if (opts.model && isQwenModel(opts.model))
+            this.model = opts.model;
+        await this.prepare();
+        if (!this.client)
+            throw new Error("qwen --acp not initialized");
+        const cwd = opts.cwd ?? this.deps.cwd ?? process.cwd();
+        // forkAtAnchor is false → ignore opts.rewindAnchor; whole-session resume only.
+        const resumeId = opts.resume ?? opts.sessionId ?? null;
+        let sessionId = await this.ensureSession(this.client, cwd, resumeId);
+        // The session id is our session id (PanelAgent persists it for resume).
+        yield {
+            type: "session",
+            sessionId,
+            ...(this.model ? { model: this.model } : {}),
+        };
+        // Process the neutral channel one turn at a time.
+        let turnSeq = 0;
+        for await (const turn of opts.channel) {
+            // LIVE MODEL SWITCH (P1): PanelAgent treats setModel as live and does NOT
+            // restart run() for a model-only change, so the persistent loop adopts it
+            // here. The model is spawn-pinned, so a switch means respawning the CLI with
+            // the new --model — which necessarily starts a FRESH session (a model swap
+            // can't carry the old session forward). Done transparently before the turn;
+            // we emit a new `session` event so PanelAgent persists the new id.
+            if (this.spawnedModel !== this.model) {
+                await this.respawnForModelChange();
+                if (!this.client)
+                    throw new Error("qwen --acp respawn failed");
+                sessionId = await this.ensureSession(this.client, cwd, null);
+                yield {
+                    type: "session",
+                    sessionId,
+                    ...(this.model ? { model: this.model } : {}),
+                };
+            }
+            yield* stampTurn(this.runTurn(this.client, turn, opts.onActivity), ++turnSeq);
+        }
+    }
+    /** Tear down the live `qwen --acp` child (process-tree kill) and re-spawn it
+     *  with the current `this.model`'s `--model` flag, so a live setModel takes
+     *  effect. The model is spawn-pinned, so this is the only way to switch it. The
+     *  caller then opens a fresh session on the new child. */
+    async respawnForModelChange() {
+        const old = this.client;
+        this.client = null;
+        this.sessionId = null;
+        if (old) {
+            old.notificationHandler = null;
+            await old.close().catch(() => { });
+        }
+        this.spawnSpec = null; // force resolveSpawn to rebuild argv with the new --model
+        logger.info(`[qwen-backend] model switch → respawning qwen --acp with --model ${this.model ?? "(default)"}`);
+        await this.prepare(); // spawns with this.model; records spawnedModel
+    }
+    /** Run ONE turn: send session/prompt + stream its session/update notifications →
+     *  AgentEvents, resolving when the prompt request returns a stopReason, OR when
+     *  the child exits mid-turn (never deadlock). ACP's prompt request IS the turn
+     *  boundary, so — unlike Codex — there is no separate completion notification and
+     *  no turn-id buffering: the sessionId is known before the prompt is sent. */
+    async *runTurn(client, turn, onActivity) {
+        const sessionId = this.sessionId;
+        // Event queue bridging the push-based notification handler to this pull-based
+        // async generator (identical pattern to gemini-backend).
+        const queue = [];
+        let wake = null;
+        let done = false;
+        const push = (ev) => {
+            queue.push(ev);
+            wake?.();
+            wake = null;
+        };
+        const finish = () => {
+            done = true;
+            wake?.();
+            wake = null;
+        };
+        // Accumulate the assistant reply text across agent_message_chunk so we can emit
+        // ONE authoritative `assistant` commit when the turn ends (ACP has no separate
+        // final-message notification). messageId (when present) groups the deltas + the
+        // commit under one bubble id, mirroring the Claude/Codex stream reconciliation.
+        let assistantText = "";
+        let messageId = null;
+        // Stream bubble state (reasoning vs reply each open/close their own stream).
+        let streamOpen = false;
+        let streamKind = null;
+        const openStream = (id, kind) => {
+            if (streamOpen && streamKind === kind)
+                return;
+            if (streamOpen)
+                push({ type: "stream_end" }); // switch kinds → close the old one
+            streamOpen = true;
+            streamKind = kind;
+            push({ type: "stream_start", id });
+        };
+        const closeStream = () => {
+            if (streamOpen) {
+                push({ type: "stream_end" });
+                streamOpen = false;
+                streamKind = null;
+            }
+        };
+        // EXACTLY ONE terminal `result` (PanelAgent's turn-gate only advances on a
+        // result; a missing one parks the channel forever). This idempotent helper
+        // emits an `error` + `{result, ok:false}` and finishes; no-op once a result
+        // has fired (so the prompt rejection AND the exit watcher can both call it).
+        let finishedResult = false;
+        const emitTerminalError = (message) => {
+            if (finishedResult)
+                return;
+            finishedResult = true;
+            closeStream();
+            push({ type: "error", message });
+            push({ type: "result", ok: false, subtype: "error" });
+            finish();
+        };
+        let interrupted = false;
+        // tool_call carries the title/kind; tool_call_update (ACP) repeats only the
+        // toolCallId — so remember each call's display name to label its end event.
+        const toolNames = new Map();
+        // Normalize ONE session/update notification into canonical AgentEvents.
+        const apply = (msg) => {
+            if (finishedResult)
+                return;
+            const params = (msg.params ?? {});
+            // Only our session's updates.
+            if (params.sessionId && params.sessionId !== sessionId)
+                return;
+            const update = (params.update ?? {});
+            const kind = update.sessionUpdate;
+            switch (kind) {
+                case "agent_message_chunk": {
+                    const content = update.content;
+                    const text = content?.type === "text" ? content.text : undefined;
+                    const id = update.messageId ?? null;
+                    if (typeof text === "string" && text) {
+                        if (id)
+                            messageId = id;
+                        openStream(messageId, "text");
+                        assistantText += text;
+                        push({ type: "assistant_delta", text });
+                    }
+                    break;
+                }
+                case "agent_thought_chunk": {
+                    // Extended-thinking streaming. Open a reasoning stream on the FIRST delta
+                    // so PanelAgent (which drops assistant_delta when no stream is open)
+                    // renders early thinking, mirroring codex P2-1.
+                    const content = update.content;
+                    const text = content?.type === "text" ? content.text : undefined;
+                    if (typeof text === "string" && text) {
+                        openStream(messageId, "thinking");
+                        push({ type: "assistant_delta", text, thinking: true });
+                    }
+                    break;
+                }
+                case "tool_call": {
+                    // A tool call was requested — emit tool_call(start) for panel visibility.
+                    const id = update.toolCallId;
+                    const name = update.title ||
+                        update.kind ||
+                        id ||
+                        "tool";
+                    if (id)
+                        toolNames.set(id, name);
+                    push({ type: "tool_call", name, phase: "start", detail: update });
+                    break;
+                }
+                case "tool_call_update": {
+                    // Progress + completion of a tool call. Emit tool_call(end) only on a
+                    // TERMINAL status; intermediate in_progress updates just keep the
+                    // watchdog armed (onActivity already fired for them). ACP's update
+                    // repeats only the toolCallId, so reuse the remembered title for the name.
+                    const status = update.status;
+                    if (status === "completed" || status === "failed") {
+                        const id = update.toolCallId;
+                        const name = update.title ||
+                            (id ? toolNames.get(id) : undefined) ||
+                            update.kind ||
+                            id ||
+                            "tool";
+                        push({ type: "tool_call", name, phase: "end", detail: update });
+                    }
+                    break;
+                }
+                // plan / available_commands_update / session_info_update / current_mode_update
+                // carry no AgentEvent — onActivity (below) already re-armed the watchdog.
+                default:
+                    break;
+            }
+        };
+        const prev = client.notificationHandler;
+        client.notificationHandler = (msg) => {
+            // LIVENESS: ANY notification while this turn is in flight means the agent is
+            // alive — fire onActivity BEFORE filtering/translating so even updates that
+            // produce no AgentEvent (a long MCP tool call mid-generation) keep
+            // PanelAgent's idle watchdog armed. A genuine zero-event freeze never
+            // reaches here, so the real freeze-catch is preserved.
+            try {
+                onActivity?.();
+            }
+            catch {
+                // a watchdog bump must never break the protocol reader
+            }
+            if (msg.method === "session/update")
+                apply(msg);
+            else
+                prev?.(msg); // anything else (other methods) → pass through
+        };
+        // Watch for the child dying mid-turn: end the turn with a terminal result so
+        // the local drain is woken instead of waiting forever. emitTerminalError is a
+        // no-op if a result already fired, so it's safe alongside the prompt rejection.
+        void client.exitPromise.then(() => {
+            if (done)
+                return;
+            emitTerminalError(client.exitError ? msgOf(client.exitError) : "qwen --acp connection closed.");
+        });
+        // FIRST-TURN PERSONA: ACP session/new has no instructions field, so the panel
+        // system prompt is prepended to the first turn's prompt as a clearly-marked
+        // system/context preamble (later turns send plain text). Mirrors gemini.
+        let turnText = promptText(turn.text);
+        if (this.needsSystemPreamble && this.deps.systemAppend) {
+            turnText =
+                `<system>\n${this.deps.systemAppend}\n</system>\n\n` +
+                    `The user's first message follows.\n\n${turnText}`;
+            this.needsSystemPreamble = false;
+        }
+        // Build the prompt ContentBlock[]: the text block first (preserves prompt
+        // context), then any resolved inline base64 image blocks (vision parity).
+        // Images are only attached when the agent advertised promptCapabilities.image
+        // (default-allow when the capability is unknown).
+        const prompt = [{ type: "text", text: turnText }];
+        const imagesAllowed = this.agentCaps?.promptCapabilities?.image !== false;
+        if (imagesAllowed) {
+            for (const ref of turn.images ?? []) {
+                const block = await this.fetchImageBlock(ref);
+                if (block)
+                    prompt.push(block);
+            }
+        }
+        try {
+            // session/prompt is a REQUEST that RESOLVES with a stopReason at turn end.
+            client
+                .request("session/prompt", { sessionId, prompt })
+                .then((res) => {
+                if (finishedResult)
+                    return;
+                finishedResult = true;
+                closeStream();
+                const stop = res?.stopReason;
+                // Commit the accumulated assistant text (if any) as the authoritative
+                // turn-ending message — no per-turn rewind anchor (forkAtAnchor=false).
+                const text = assistantText.trim();
+                if (text)
+                    push({ type: "assistant", text, ...(messageId ? { id: messageId } : {}) });
+                // end_turn / max_tokens / max_turn_requests = a real completion; cancelled
+                // (user interrupt) and refusal are not "ok".
+                const ok = !!stop && stop !== "cancelled" && stop !== "refusal";
+                push({ type: "result", ok, ...(stop ? { subtype: stop } : {}) });
+                finish();
+            })
+                .catch((err) => {
+                // A failed prompt ends the turn. When the child dies mid-turn handleExit
+                // rejects this BEFORE exitPromise resolves, so this .catch runs first —
+                // it MUST end with a terminal result (the idempotent helper guarantees
+                // exactly one), or the exit watcher then sees done and hangs the gate.
+                if (interrupted)
+                    emitTerminalError("qwen turn interrupted.");
+                else
+                    emitTerminalError(msgOf(err));
+            });
+            // Drain the bridged queue until the turn completes.
+            while (true) {
+                while (queue.length) {
+                    yield queue.shift();
+                }
+                if (done)
+                    break;
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+            }
+            while (queue.length)
+                yield queue.shift();
+        }
+        finally {
+            // Mark interrupted so a late prompt rejection doesn't surface a spurious
+            // error after teardown.
+            interrupted = true;
+            // Restore the prior handler ONLY if it's still ours (close() may have nulled
+            // it during shutdown — don't resurrect a stale handler onto a dead client).
+            if (client.notificationHandler && !client.exitError)
+                client.notificationHandler = prev ?? null;
+        }
+    }
+    /** Stop the current turn without ending the session → `session/cancel`
+     *  (notification). The in-flight session/prompt then resolves with
+     *  stopReason:"cancelled", which the run-turn path turns into a terminal result. */
+    async interrupt() {
+        const client = this.client;
+        if (!client || !this.sessionId)
+            return;
+        try {
+            client.notify("session/cancel", { sessionId: this.sessionId });
+        }
+        catch (err) {
+            logger.debug(`[qwen-backend] interrupt: ${msgOf(err)}`);
+        }
+    }
+    /** Switch the model live. ACP pins the model at spawn (`--model`), so this can't
+     *  reconfigure a running child — instead it marks the model dirty (this.model !=
+     *  this.spawnedModel) and invalidates the cached spawn spec. The persistent run()
+     *  loop then RESPAWNS the `qwen --acp` CLI with the new --model (and a fresh
+     *  session) transparently before the next turn (see run()'s live-switch branch).
+     *  If the backend hasn't spawned yet, the first prepare() simply uses the new
+     *  model. Ignores non-Qwen ids (PanelAgent may pass the Claude panel model). */
+    async setModel(model) {
+        if (!isQwenModel(model))
+            return;
+        this.model = model;
+        this.spawnSpec = null; // next spawn rebuilds argv with the new --model
+    }
+    /**
+     * Qwen model enumeration. ACP exposes no model catalog, so we surface a static
+     * set (the current Qwen coding family); the panel picker degrades gracefully on
+     * an empty list. No effort metadata (no discrete effort scale) → the panel
+     * hides the effort dropdown.
+     */
+    async listModels() {
+        return QWEN_MODELS;
+    }
+    /** Permanently dispose of the backend (AgentBackend.close): kill the qwen
+     *  process TREE (Windows shell-fallback grandchild included), remove listeners,
+     *  null the client. Idempotent + safe when never prepared. Mirrors codex (P0-1):
+     *  interrupt() is a no-op when idle, so without this the child is orphaned. */
+    async close() {
+        this.disposed = true; // tripwire FIRST (an in-flight prepare() bails) (P0-A)
+        const client = this.client;
+        const preparing = this.preparingClient;
+        this.client = null;
+        this.preparingClient = null;
+        this.sessionId = null;
+        if (client) {
+            client.notificationHandler = null;
+            await client.close().catch(() => { });
+        }
+        if (preparing && preparing !== client) {
+            preparing.notificationHandler = null;
+            await preparing.close().catch(() => { });
+        }
+    }
+}
+// Expose the default model id for the orchestrator wiring (COMFYUI_MCP_QWEN_MODEL
+// fallback) without duplicating the literal.
+export { QWEN_DEFAULT_MODEL };
+//# sourceMappingURL=qwen-backend.js.map