@linkshell/host 0.4.18 → 0.4.20

package/dist/host/src/drivers/acp/driver.js

@@ -1,7 +1,15 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { RpcError, } from "@linkshell/wire";
-import { AcpConnection } from "./connection.js";
+import { createHash } from "node:crypto";
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { RpcError, acpAgentSettingsSchema, acpProviderSchema, questionAnswerError, } from "@linkshell/wire";
+import { AcpClientServices } from "./client-services.js";
+import { AcpUpdates, usageUpdate } from "./updates.js";
+import { AcpMcpBridge } from "./mcp.js";
+import { AcpEditor } from "./editor.js";
+import { AcpConnection, AcpProtocolError } from "./connection.js";
 import { mapAcpQuestions, questionMethod } from "./questions.js";
 import { AcpItemTracker, mapPermissionRequest, normalizeAcpUpdate, toAcpPrompt, withContext, toConfigOptions, toHistory, toStopReason, } from "./mapper.js";
 const execFileAsync = promisify(execFile);
@@ -39,6 +47,7 @@ export class AcpDriver {
     label;
     tier;
     capabilities = {
+        acp: true,
         interrupt: true,
         steer: false,
         permissions: true,
@@ -58,12 +67,50 @@ export class AcpDriver {
     stopped = false;
     nextPermissionId = 1;
     authenticating;
+    credentialsChanged = false;
+    services;
+    mcp;
+    edits;
+    serviceRequests = new Map();
+    terminalCalls = new Map();
+    interactions = new Map();
+    children = new Map();
+    discoveredDirectories = new Map();
     constructor(spec, options) {
         this.spec = spec;
         this.options = options;
         this.id = spec.id;
         this.label = spec.label;
         this.tier = spec.tier;
+        this.services = new AcpClientServices({ env: this.env,
+            scope: (id) => { const state = this.sessions.get(id); return state ? { cwd: state.cwd, additionalDirectories: state.settings.additionalDirectories } : undefined; },
+            output: (id, terminalId, text, snapshot) => {
+                for (const call of this.terminalCalls.get(`${id}\n${terminalId}`) ?? []) {
+                    // The first terminal reference carries the backlog; later output is already a delta.
+                    if (text)
+                        this.emit(id, { sessionUpdate: "tool_call_update", toolCallId: call, appendOutput: text });
+                    if (snapshot.exitStatus)
+                        this.emit(id, { sessionUpdate: "tool_call_update", toolCallId: call, rawOutput: { truncated: snapshot.truncated, ...snapshot.exitStatus } });
+                }
+            },
+        });
+        this.mcp = new AcpMcpBridge({ env: this.env,
+            notify: (params) => this.connection?.notify("mcp/message", params),
+            request: async (sessionId, method, params, id) => {
+                if (method === "ping")
+                    return {};
+                const state = sessionId ? this.sessions.get(sessionId) : undefined;
+                if (method === "roots/list" && state)
+                    return { roots: [state.cwd, ...state.settings.additionalDirectories].map((path) => ({ uri: pathToFileURL(path).href, name: path })) };
+                if (method === "elicitation/create" && state)
+                    return this.onQuestions(method, { mode: "form", ...params, sessionId }, id);
+                throw new RpcError(-32601, `MCP 客户端不支持 ${method}`);
+            },
+        });
+        this.edits = new AcpEditor({ capabilities: () => this.connection?.capabilities ?? {}, settings: () => this.settings(),
+            request: (method, params) => this.connection?.request(method, params, method === "nes/close" ? 5000 : 30_000) ?? Promise.reject(RpcError.app("offline", "ACP 连接已关闭")),
+            notify: (method, params) => this.connection?.notify(method, params),
+        });
     }
     status() {
         return this.current;
@@ -95,8 +142,173 @@ export class AcpDriver {
             clearTimeout(this.restartTimer);
         for (const state of this.sessions.values())
             this.cancelPermissions(state);
+        for (const id of [...this.interactions.keys()])
+            this.resolveInteraction(id, "cancel");
+        await this.edits.close();
         await this.connection?.stop();
         this.connection = undefined;
+        for (const controller of this.serviceRequests.values())
+            controller.abort();
+        this.serviceRequests.clear();
+        this.terminalCalls.clear();
+        await this.services.close();
+        await this.mcp.close();
+    }
+    async acpInfo(nativeId) {
+        await this.ensureStarted();
+        if (!this.connection?.alive)
+            throw RpcError.app("agent_unavailable", this.current.problem ?? "ACP 启动失败");
+        const caps = this.connection.capabilities;
+        return { features: {
+                protocolVersion: this.connection.protocolVersion,
+                authMethods: (this.connection.initializeResult.authMethods ?? []).filter((method) => !method.type || ["terminal", "agent"].includes(method.type)).map((method) => ({ id: method.id, name: method.name ?? method.id, description: method.description ?? undefined, type: method.type === "terminal" ? "terminal" : "agent" })),
+                logout: this.connection.protocolVersion === 2 ? caps.auth !== undefined : Boolean(caps.auth?.logout), providers: Boolean(caps.providers) && this.settings().experimental,
+                nes: Boolean(caps.nes) && this.settings().experimental,
+                additionalDirectories: Boolean(caps.sessionCapabilities?.additionalDirectories), mcpHttp: caps.mcpCapabilities?.http === true, mcpSse: caps.mcpCapabilities?.sse === true,
+            }, settings: nativeId ? this.sessions.get(nativeId)?.settings ?? this.settings() : this.settings(), interactions: this.pendingInteractions() };
+    }
+    async editor(input) { await this.ensureStarted(); return this.edits.run(input); }
+    pendingInteractions() { return [...this.interactions.values()].map((entry) => entry.request.update); }
+    async configureAcp(settings, nativeId) {
+        settings = acpAgentSettingsSchema.parse(settings);
+        await this.validateDirectories(settings);
+        const affected = nativeId ? [this.sessions.get(nativeId)].filter((state) => !!state) : [...this.sessions.values()];
+        if (affected.some((state) => state.turnActive || state.inflight || state.permissions.size || state.questions.size) || this.interactions.size)
+            throw RpcError.app("busy", "请先结束运行和待处理的交互，再修改 ACP 配置");
+        if (nativeId) {
+            if (settings.protocolVersion !== this.settings().protocolVersion || settings.experimental !== this.settings().experimental)
+                throw RpcError.app("invalid_params", "协议版本和实验功能需要在 AI 全局设置中修改");
+            this.validateSessionSettings(settings);
+            await this.detach(nativeId);
+            this.host?.state(this.id, nativeId).set("acp-settings", JSON.stringify(settings));
+            const state = this.sessions.get(nativeId);
+            if (state)
+                state.settings = settings;
+            this.host?.detached(this.id, nativeId);
+        }
+        else {
+            await this.stop();
+            this.stopped = false;
+            this.children.clear();
+            for (const [id, state] of this.sessions) {
+                state.loaded = false;
+                if (!this.host?.state(this.id, id).get("acp-settings"))
+                    state.settings = settings;
+                this.host?.detached(this.id, id);
+            }
+        }
+    }
+    async authenticate(methodId, logout = false) {
+        const { features } = await this.acpInfo();
+        if (logout) {
+            if (!features.logout)
+                throw RpcError.app("not_supported", "这个 AI 不支持退出登录");
+            if ([...this.sessions.values()].some((state) => state.turnActive))
+                throw RpcError.app("busy", "请先结束正在运行的会话");
+            await this.rpc(this.connection.protocolVersion === 2 ? "auth/logout" : "logout", {});
+            this.signedOut = { state: "missing" };
+            return {};
+        }
+        const method = this.connection.initializeResult.authMethods?.find((entry) => entry.id === methodId);
+        if (!method || (method.type && !["agent", "terminal"].includes(method.type)))
+            throw RpcError.app("invalid_params", "请选择可用的登录方式");
+        if (method.type === "terminal") {
+            if (!this.host?.loginTerminal || ["http", "websocket"].includes(this.spec.transport ?? ""))
+                throw RpcError.app("not_supported", "这个连接不支持终端登录");
+            const launch = await this.host.loginTerminal(this.id, { command: this.spec.command, args: [...this.spec.args, ...(method.args ?? [])], env: { ...this.spec.env, ...method.env } });
+            void launch.exited.then((code) => {
+                if (this.stopped)
+                    return;
+                this.signedOut = code === 0 ? { state: "ok" } : { state: "missing", hint: "终端登录未成功，请重试" };
+                this.credentialsChanged = code === 0;
+                this.host?.authChanged?.(this.id);
+            });
+            return { terminalId: launch.terminalId };
+        }
+        await this.rpc(this.connection.protocolVersion === 2 ? "auth/login" : "authenticate", { methodId }, 0);
+        this.signedOut = { state: "ok" };
+        return {};
+    }
+    async providers(operation, config) {
+        const { features } = await this.acpInfo();
+        if (!features.providers)
+            throw RpcError.app("not_supported", "这个 AI 不支持供应商配置");
+        const list = async () => {
+            const response = await this.rpc("providers/list", {});
+            return response.providers.map((provider) => acpProviderSchema.parse(provider));
+        };
+        if (operation === "list")
+            return list();
+        const provider = (await list()).find((entry) => entry.providerId === config?.providerId);
+        if (!provider || !config)
+            throw RpcError.app("invalid_params", "供应商不存在");
+        if (operation === "disable" && provider.required)
+            throw RpcError.app("invalid_params", "不能停用必需的供应商");
+        if (operation === "set" && (!config.apiType || !provider.supported.includes(config.apiType) || !config.baseUrl))
+            throw RpcError.app("invalid_params", "供应商地址或协议无效");
+        await this.rpc(`providers/${operation}`, operation === "disable" ? { providerId: config.providerId } : { ...config, headers: config.headers ?? {} });
+        return list();
+    }
+    async respondInteraction(requestId, response) {
+        const pending = this.interactions.get(requestId);
+        if (!pending)
+            throw RpcError.app("not_found", "这个请求已结束");
+        if (response.answers) {
+            const error = (pending.request.update.questions ?? []).map((question) => questionAnswerError(question, response.answers.find((answer) => answer.id === question.id))).find(Boolean);
+            if (error)
+                throw RpcError.app("invalid_params", error);
+            const result = pending.request.answer(response.answers);
+            this.interactions.delete(requestId);
+            pending.resolve(result);
+            this.host?.interaction?.(this.id, { requestId, resolved: true });
+        }
+        else {
+            if (!pending.request.update.options.some((option) => option.optionId === response.optionId))
+                throw RpcError.app("invalid_params", "选项已失效");
+            this.resolveInteraction(requestId, response.optionId);
+        }
+    }
+    resolveInteraction(requestId, optionId) {
+        const pending = this.interactions.get(requestId);
+        if (!pending)
+            return;
+        this.interactions.delete(requestId);
+        pending.resolve(pending.request.respond(optionId));
+        this.host?.interaction?.(this.id, { requestId, resolved: true });
+    }
+    async validateDirectories(settings) {
+        for (const path of settings.additionalDirectories) {
+            if (!isAbsolute(path) || !await stat(await realpath(path)).then((info) => info.isDirectory()).catch(() => false))
+                throw RpcError.app("invalid_params", `附加目录不存在或不是绝对路径：${path}`);
+        }
+        if (new Set(settings.mcpServers.map((server) => server.name)).size !== settings.mcpServers.length)
+            throw RpcError.app("invalid_params", "MCP 服务名称不能重复");
+    }
+    validateSessionSettings(settings) {
+        const caps = this.connection?.capabilities;
+        if (settings.additionalDirectories.length && !caps?.sessionCapabilities?.additionalDirectories)
+            throw RpcError.app("not_supported", "这个 AI 未声明支持附加目录");
+        for (const server of settings.mcpServers) {
+            if ((server.type === "http" || server.type === "sse") && !caps?.mcpCapabilities?.[server.type])
+                throw RpcError.app("not_supported", `这个 AI 不支持 ${server.type} MCP 服务`);
+            if (server.type === "stdio" && this.connection?.protocolVersion === 2 && !caps?.mcpCapabilities?.stdio)
+                throw RpcError.app("not_supported", "这个 AI 不支持 stdio MCP 服务");
+            if (server.type === "acp" && !caps?.mcpCapabilities?.acp)
+                throw RpcError.app("not_supported", "这个 AI 不支持通过 ACP 连接 MCP 服务");
+        }
+    }
+    async sessionParameters(cwd, settings = this.settings()) {
+        await this.ensureStarted();
+        await this.validateDirectories(settings);
+        this.validateSessionSettings(settings);
+        const v2 = this.connection?.protocolVersion === 2;
+        return { cwd, mcpServers: settings.mcpServers.map((server) => {
+                if (server.type === "stdio")
+                    return { ...(v2 ? { type: "stdio" } : {}), name: server.name, command: server.command, args: server.args, env: Object.entries(server.env).map(([name, value]) => ({ name, value })) };
+                if (server.type === "acp")
+                    return { type: "acp", name: server.name, serverId: this.mcp.open(server, cwd) };
+                return { type: server.type, name: server.name, url: server.url, headers: Object.entries(server.headers).map(([name, value]) => ({ name, value })) };
+            }), ...(settings.additionalDirectories.length ? { additionalDirectories: settings.additionalDirectories } : {}), ...this.sessionMeta() };
     }
     async listSessions(limit) {
         if (!this.connection?.alive || !this.connection.capabilities.sessionCapabilities?.list)
@@ -106,8 +318,13 @@ export class AcpDriver {
         do {
             const page = await this.rpc("session/list", cursor ? { cursor } : {});
             for (const info of page.sessions ?? []) {
+                if (Array.isArray(info.additionalDirectories) && info.additionalDirectories.every((path) => typeof path === "string" && isAbsolute(path)))
+                    this.discoveredDirectories.set(info.sessionId, info.additionalDirectories);
                 const updatedAt = info.updatedAt ? Date.parse(info.updatedAt) || Date.now() : Date.now();
-                found.push({ nativeId: info.sessionId, cwd: info.cwd, title: info.title ?? undefined, createdAt: updatedAt, updatedAt });
+                found.push({
+                    nativeId: info.sessionId, cwd: info.cwd, title: info.title ?? undefined, createdAt: updatedAt, updatedAt,
+                    state: await this.discoveredState(info.sessionId, info.cwd),
+                });
                 if (found.length >= limit)
                     return found;
             }
@@ -115,6 +332,19 @@ export class AcpDriver {
         } while (cursor);
         return found;
     }
+    /** ACP v1 does not include live state in session/list; only this connection's turns are known. */
+    async discoveredState(nativeId, _cwd) {
+        return this.localState(nativeId);
+    }
+    localState(nativeId) {
+        const state = this.sessions.get(nativeId);
+        if (state?.permissions.size || state?.questions.size)
+            return "waiting";
+        for (const [id, child] of this.sessions)
+            if ((child.permissions.size || child.questions.size) && this.isChildOf(id, nativeId))
+                return "waiting";
+        return state?.reportedState ?? (state?.turnActive ? "running" : "idle");
+    }
     /** ACP's session/fork, for agents that offer it: the whole conversation, in `cwd`. */
     async fork(nativeId, options) {
         if (!this.connection?.alive)
@@ -123,7 +353,9 @@ export class AcpDriver {
             throw RpcError.app("not_supported", `${this.label} 不支持从会话分叉`);
         if (options.upTo)
             throw RpcError.app("not_supported", `${this.label} 只能分叉整个会话`);
-        const response = await this.rpc("session/fork", { sessionId: nativeId, cwd: options.cwd, mcpServers: [], ...this.sessionMeta() });
+        const settings = this.sessions.get(nativeId)?.settings ?? this.settings();
+        const response = await this.rpc("session/fork", { sessionId: nativeId, ...await this.sessionParameters(options.cwd, settings) });
+        this.stateFor(response.sessionId, options.cwd).settings = settings;
         const now = Date.now();
         return { nativeId: response.sessionId, cwd: options.cwd, createdAt: now, updatedAt: now };
     }
@@ -135,12 +367,13 @@ export class AcpDriver {
         return this.id === "claude" ? { _meta: { claudeCode: { emitRawSDKMessages: [{ type: "active_goal" }] } } } : {};
     }
     async createSession(options) {
+        await this.ensureStarted();
+        if (this.connection?.capabilities.sessions === false)
+            throw RpcError.app("not_supported", "这个 ACP Agent 不支持会话，可在文件中使用编辑建议");
         let response;
         try {
             response = await this.rpc("session/new", {
-                cwd: options.cwd,
-                mcpServers: [],
-                ...this.sessionMeta(),
+                ...await this.sessionParameters(options.cwd),
             });
         }
         catch (error) {
@@ -150,31 +383,44 @@ export class AcpDriver {
         const state = this.stateFor(response.sessionId, options.cwd);
         state.loaded = true;
         state.config = toConfigOptions(response);
+        this.sessionCommands(state, response);
         if (options.model)
             await this.setConfig(response.sessionId, "model", options.model).catch(() => { });
         const now = Date.now();
         return { nativeId: response.sessionId, cwd: options.cwd, createdAt: now, updatedAt: now, state: "idle" };
     }
     async attach(nativeId, context) {
+        // Lazy agents have no capabilities until initialize has completed.
+        await this.ensureStarted();
+        if (!this.connection?.alive)
+            throw RpcError.app("agent_unavailable", this.current.problem ?? `${this.label} 尚未启动`);
         const state = this.stateFor(nativeId, context.cwd);
         if (state.loaded) {
             this.emitConfig(nativeId, state);
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: this.localState(nativeId), turnActive: state.turnActive });
             return [];
         }
         const capabilities = this.connection?.capabilities;
         let history = [];
-        if (capabilities?.loadSession) {
+        state.config = [];
+        state.commands = undefined;
+        if (capabilities?.loadSession || this.connection.protocolVersion === 2) {
             state.replaying = [];
+            state.updates = new AcpUpdates();
             try {
-                const response = await this.rpc("session/load", {
+                const response = await this.rpc(this.connection.protocolVersion === 2 ? "session/resume" : "session/load", {
                     sessionId: nativeId,
-                    cwd: context.cwd,
-                    mcpServers: [],
-                    ...this.sessionMeta(),
+                    ...await this.sessionParameters(context.cwd, state.settings),
+                    ...(this.connection.protocolVersion === 2 ? { replayFrom: { type: "start" } } : {}),
                 });
-                state.config = toConfigOptions(response);
+                if (response.configOptions !== undefined || response.modes !== undefined || response.models !== undefined)
+                    state.config = this.mergeConfig(state, toConfigOptions(response));
+                this.sessionCommands(state, response);
                 state.tracker = new AcpItemTracker();
-                history = toHistory(state.replaying, state.tracker);
+                const unfinished = [];
+                history = toHistory(state.replaying, state.tracker, undefined, unfinished);
+                if (unfinished.length)
+                    history.push({ itemId: `acp:snapshot:${createHash("sha256").update(JSON.stringify(unfinished)).digest("hex")}`, updates: unfinished });
             }
             finally {
                 state.replaying = undefined;
@@ -183,17 +429,24 @@ export class AcpDriver {
         else if (capabilities?.sessionCapabilities?.resume) {
             const response = await this.rpc("session/resume", {
                 sessionId: nativeId,
-                cwd: context.cwd,
-                mcpServers: [],
-                ...this.sessionMeta(),
+                ...await this.sessionParameters(context.cwd, state.settings),
             });
             state.config = toConfigOptions(response);
+            this.sessionCommands(state, response);
+            history.push({
+                itemId: "linkshell:acp-history-unavailable",
+                updates: [{
+                        sessionUpdate: "ls_notice", level: "info", title: "这个 AI 暂不提供以往消息",
+                        detail: "会话已恢复；这里只显示 LinkShell 已缓存的内容和之后的新消息。",
+                    }],
+            });
         }
         else {
-            throw RpcError.app("not_supported", `${this.label} can't reopen earlier sessions`);
+            throw RpcError.app("not_supported", `${this.label} 当前版本不支持恢复以往会话；已缓存的消息仍可查看。`);
         }
         state.loaded = true;
         this.emitConfig(nativeId, state);
+        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: this.localState(nativeId), turnActive: state.turnActive });
         return history;
     }
     async detach(nativeId) {
@@ -202,6 +455,11 @@ export class AcpDriver {
             return;
         state.loaded = false;
         this.cancelPermissions(state);
+        await this.services.close(nativeId);
+        await this.mcp.close(nativeId);
+        for (const key of this.terminalCalls.keys())
+            if (key.startsWith(`${nativeId}\n`))
+                this.terminalCalls.delete(key);
         if (this.connection?.capabilities.sessionCapabilities?.close) {
             await this.rpc("session/close", { sessionId: nativeId }).catch(() => { });
         }
@@ -210,13 +468,19 @@ export class AcpDriver {
         const state = this.sessions.get(nativeId);
         if (!state?.loaded)
             throw RpcError.app("not_ready", "session is not open");
+        if (state.reportedState === "unknown")
+            throw RpcError.app("not_ready", "Agent 尚未确认当前执行状态，请刷新会话或停止后重试");
+        for (const block of content) {
+            if (block.type === "image" && !this.capabilities.images || block.type === "audio" && !this.capabilities.audio || block.type === "resource" && !this.capabilities.embeddedContext)
+                throw RpcError.app("not_supported", `${this.label} 未声明支持这种附件`);
+        }
         const prompt = toAcpPrompt(content);
         if (prompt.length === 0)
             throw RpcError.app("invalid_params", "nothing to send");
         if (state.turnActive) {
             if (this.capabilities.steer) {
                 this.echoUserMessage(nativeId, content, clientMessageId);
-                void this.sendPrompt(nativeId, state, withContext(prompt, context));
+                void this.sendPrompt(nativeId, state, withContext(prompt, context), clientMessageId);
                 return "steered";
             }
             state.queue.push({ content, clientMessageId, context });
@@ -236,6 +500,12 @@ export class AcpDriver {
         this.cancelPermissions(state);
         this.connection?.notify("session/cancel", { sessionId: nativeId });
     }
+    async cancelSubagent(nativeId, childId) {
+        const permitted = [...this.children.get(childId)?.entries() ?? []].some(([parent, association]) => association.canCancel && (parent === nativeId || this.isChildOf(parent, nativeId)));
+        if (!permitted)
+            throw RpcError.app("not_supported", "这个子代理未允许单独停止");
+        this.connection?.notify("session/cancel", { sessionId: childId });
+    }
     /** Stops the running turn only: the first queued message starts as soon as it has ended. */
     async sendQueuedNow(nativeId) {
         const state = this.sessions.get(nativeId);
@@ -245,20 +515,21 @@ export class AcpDriver {
         this.connection?.notify("session/cancel", { sessionId: nativeId });
     }
     async respondPermission(nativeId, requestId, optionId) {
-        const question = this.sessions.get(nativeId)?.questions.get(requestId);
+        const owner = this.requestOwner(nativeId, requestId);
+        const question = owner?.state.questions.get(requestId);
         if (question) {
             // Not answering: skip (the agent goes on without an answer) or stop.
-            this.sessions.get(nativeId)?.questions.delete(requestId);
+            owner.state.questions.delete(requestId);
             question.resolve(question.request.respond(optionId));
-            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
+            this.publish(owner.id, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
             return;
         }
-        const resolve = this.sessions.get(nativeId)?.permissions.get(requestId);
-        if (!resolve)
+        const pending = owner?.state.permissions.get(requestId);
+        if (!pending)
             throw RpcError.app("not_found", "this permission request is no longer pending");
-        this.sessions.get(nativeId)?.permissions.delete(requestId);
-        resolve({ outcome: { outcome: "selected", optionId } });
-        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
+        owner.state.permissions.delete(requestId);
+        pending.resolve({ outcome: { outcome: "selected", optionId } });
+        this.publish(owner.id, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
     }
     async setConfig(nativeId, optionId, value) {
         const state = this.sessions.get(nativeId);
@@ -275,13 +546,24 @@ export class AcpDriver {
             await this.rpc("session/set_model", { sessionId: nativeId, modelId: value });
         }
         else {
-            await this.rpc("session/set_config_option", { sessionId: nativeId, configId: optionId, value });
+            const response = await this.rpc("session/set_config_option", {
+                sessionId: nativeId, configId: optionId, ...(option.type === "boolean" ? { type: "boolean", value: value === "on" } : { ...(this.connection?.protocolVersion === 2 ? { type: "select" } : {}), value }),
+            });
+            if (Array.isArray(response.configOptions)) {
+                state.config = this.mergeConfig(state, toConfigOptions(response));
+                this.emitConfig(nativeId, state);
+                return;
+            }
         }
         option.current = value;
         this.emitConfig(nativeId, state);
     }
     // ── internals ──────────────────────────────────────────────────────
     async detectVersion() {
+        if (this.spec.transport === "http" || this.spec.transport === "websocket")
+            return "remote";
+        if (this.spec.transport === "stdio")
+            return "";
         const probe = this.spec.version ?? { command: this.spec.command, args: ["--version"] };
         try {
             const { stdout, stderr } = await execFileAsync(probe.command, probe.args, { env: this.env, timeout: 15_000 });
@@ -296,22 +578,63 @@ export class AcpDriver {
     booting;
     /** Starts the agent process once; concurrent callers share the attempt. */
     ensureStarted() {
-        if (this.connection?.alive)
+        const refresh = this.credentialsChanged && ![...this.sessions.values()].some((state) => state.turnActive);
+        if (this.connection?.alive && !refresh)
             return Promise.resolve();
-        this.booting ??= this.boot().finally(() => {
+        this.booting ??= (async () => {
+            if (refresh) {
+                this.credentialsChanged = false;
+                await this.connection?.stop();
+                this.connection = undefined;
+                for (const [id, state] of this.sessions) {
+                    state.loaded = false;
+                    this.host?.detached(this.id, id);
+                }
+            }
+            await this.boot();
+        })().finally(() => {
             this.booting = undefined;
         });
         return this.booting;
     }
     async boot() {
+        const settings = this.settings();
+        const remote = this.spec.transport === "http" || this.spec.transport === "websocket";
+        const headers = {};
+        for (const [key, name] of Object.entries(this.spec.headerEnv ?? {})) {
+            const value = this.env[name];
+            if (value)
+                headers[key] = value;
+        }
         const connection = new AcpConnection({
             command: this.spec.command,
             args: this.spec.args,
             env: this.env,
+            protocolVersion: settings.protocolVersion,
+            experimental: settings.experimental,
+            transport: remote ? { type: this.spec.transport, url: this.spec.url, headers } : undefined,
             clientVersion: this.options.hostVersion,
             onUpdate: (sessionId, update) => this.onUpdate(sessionId, update),
             onRequest: (method, params, id) => this.onRequest(method, params, id),
             onCancelRequest: (id) => this.cancelQuestionRequest(id),
+            onNotification: (method, params) => {
+                if (method !== "elicitation/complete")
+                    return;
+                const id = params?.elicitationId;
+                if (!id)
+                    return;
+                for (const [requestId, pending] of this.interactions)
+                    if (pending.request.update.url?.elicitationId === id)
+                        this.resolveInteraction(requestId, "cancel");
+                for (const [sessionId, state] of this.sessions)
+                    for (const [requestId, pending] of state.questions) {
+                        if (pending.request.update.url?.elicitationId !== id)
+                            continue;
+                        state.questions.delete(requestId);
+                        pending.resolve(pending.request.respond("cancel"));
+                        this.host?.update(this.id, sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
+                    }
+            },
             onExit: (reason) => this.onExit(reason),
         });
         this.connection = connection;
@@ -325,18 +648,22 @@ export class AcpDriver {
                 ...this.capabilities,
                 steer: steering || queueing,
                 images: caps.promptCapabilities?.image === true,
+                audio: caps.promptCapabilities?.audio === true,
+                embeddedContext: caps.promptCapabilities?.embeddedContext === true,
                 fork: Boolean(caps.sessionCapabilities?.fork),
             };
             this.current = { installed: true, version: this.current.version };
             this.restartDelay = 1000;
         }
         catch (error) {
+            await connection.stop();
             this.current = {
                 installed: true,
                 version: this.current.version,
                 problem: `${this.label} failed to start: ${error instanceof Error ? error.message : String(error)}`,
             };
-            this.scheduleRestart();
+            if (!(error instanceof AcpProtocolError))
+                this.scheduleRestart();
         }
     }
     scheduleRestart() {
@@ -356,6 +683,15 @@ export class AcpDriver {
         if (this.stopped)
             return;
         this.host?.log(`[${this.id}] ${reason}`);
+        for (const controller of this.serviceRequests.values())
+            controller.abort();
+        this.serviceRequests.clear();
+        this.terminalCalls.clear();
+        void this.services.close();
+        void this.mcp.close();
+        void this.edits.close();
+        for (const id of [...this.interactions.keys()])
+            this.resolveInteraction(id, "cancel");
         for (const [nativeId, state] of this.sessions) {
             if (!state.loaded)
                 continue;
@@ -374,10 +710,15 @@ export class AcpDriver {
     stateFor(nativeId, cwd) {
         let state = this.sessions.get(nativeId);
         if (!state) {
+            const saved = this.host?.state(this.id, nativeId).get("acp-settings");
             state = {
                 cwd,
+                settings: saved ? acpAgentSettingsSchema.parse(JSON.parse(saved)) : { ...this.settings(), ...(this.discoveredDirectories.has(nativeId) ? { additionalDirectories: this.discoveredDirectories.get(nativeId) } : {}) },
                 loaded: false,
                 tracker: new AcpItemTracker(),
+                updates: new AcpUpdates(),
+                messageAliases: new Map(JSON.parse(this.host?.state(this.id, nativeId).get("acp-message-aliases") ?? "[]")),
+                deferredUserUpdates: [],
                 config: [],
                 turnActive: false,
                 inflight: 0,
@@ -391,36 +732,168 @@ export class AcpDriver {
         return state;
     }
     emitConfig(nativeId, state) {
-        if (state.config.length === 0)
-            return;
         this.host?.update(this.id, nativeId, {
             sessionUpdate: "ls_config",
             options: state.config.map(({ source: _source, ...option }) => option),
         });
+        if (state.commands)
+            this.host?.update(this.id, nativeId, state.commands);
+    }
+    sessionCommands(state, response) {
+        const commands = response.availableCommands;
+        if (!Array.isArray(commands))
+            return;
+        const update = normalizeAcpUpdate({ sessionUpdate: "available_commands_update", availableCommands: commands });
+        if (update?.sessionUpdate === "available_commands_update")
+            state.commands = update;
+    }
+    mergeConfig(state, options) {
+        return [...options, ...state.config.filter((option) => option.source !== "configOptions" && !options.some((next) => next.id === option.id || next.category === option.category))];
     }
     /** Feeds an update through the item tracker and on to the host. */
     emit(nativeId, update) {
         const state = this.sessions.get(nativeId);
         const tracked = state ? state.tracker.feed(update) : [{ update }];
         for (const entry of tracked)
-            this.host?.update(this.id, nativeId, entry.update, entry.itemId);
+            this.publish(nativeId, entry.update, entry.itemId);
     }
     closeMessage(nativeId) {
         const state = this.sessions.get(nativeId);
         if (!state)
             return;
         for (const entry of state.tracker.close())
-            this.host?.update(this.id, nativeId, entry.update, entry.itemId);
+            this.publish(nativeId, entry.update, entry.itemId);
+    }
+    /** Child streams reuse the existing nested timeline and never overwrite the parent's settings or status. */
+    publish(nativeId, update, itemId) {
+        const parents = this.children.get(nativeId);
+        if (!parents?.size) {
+            this.host?.update(this.id, nativeId, update, itemId);
+            return;
+        }
+        if (["ls_status", "ls_config", "session_info_update", "usage_update", "available_commands_update", "current_mode_update", "ls_goal", "plan"].includes(update.sessionUpdate))
+            return;
+        const prefix = `acp:${encodeURIComponent(nativeId)}:`;
+        for (const [parent, association] of parents) {
+            const mapped = update.sessionUpdate === "user_message_chunk"
+                ? { sessionUpdate: "ls_message", messageId: update.messageId ?? "prompt", role: "user", content: [update.content], append: true }
+                : { ...update };
+            if ("messageId" in mapped && mapped.messageId)
+                mapped.messageId = prefix + mapped.messageId;
+            if ("toolCallId" in mapped && mapped.toolCallId)
+                mapped.toolCallId = prefix + mapped.toolCallId;
+            if (["agent_message_chunk", "agent_thought_chunk", "ls_message", "ls_message_done", "tool_call", "tool_call_update", "ls_turn"].includes(mapped.sessionUpdate)) {
+                mapped.parentToolCallId = "parentToolCallId" in update && update.parentToolCallId ? prefix + update.parentToolCallId : this.childCallId(nativeId);
+            }
+            if (mapped.sessionUpdate === "ls_permission") {
+                mapped.title = `${association.title ?? "子代理"} · ${mapped.title}`;
+                mapped.childSessionId ??= nativeId;
+            }
+            this.onMappedUpdate(parent, mapped);
+        }
+    }
+    childCallId(id) { return `acp:subagent:${encodeURIComponent(id)}`; }
+    subagentUpdate(parent, raw) {
+        const update = raw;
+        const childId = update.sessionId;
+        if (typeof childId !== "string" || childId === parent || this.isChildOf(parent, childId))
+            return;
+        const parentState = this.sessions.get(parent);
+        if (!parentState)
+            return;
+        const parents = this.children.get(childId) ?? new Map();
+        const created = !parents.has(parent);
+        const association = parents.get(parent) ?? { canCancel: false };
+        if (update.title !== undefined)
+            association.title = update.title ?? undefined;
+        if (update.description !== undefined)
+            association.description = update.description ?? undefined;
+        if (update.capabilities !== undefined)
+            association.canCancel = !!update.capabilities?.cancel;
+        if (update.state !== undefined)
+            association.state = update.state;
+        parents.set(parent, association);
+        this.children.set(childId, parents);
+        const child = this.stateFor(childId, parentState.cwd);
+        child.loaded = true;
+        child.settings = parentState.settings;
+        const status = association.state;
+        const state = status?.state === "running" ? "running" : status?.state === "requires_action" ? "paused" : status?.state === "idle"
+            ? status.stopReason === "cancelled" ? "stopped" : status.stopReason === "error" ? "failed" : status.stopReason ? "completed" : "unknown" : "unknown";
+        const call = {
+            toolCallId: this.childCallId(childId), title: association.title ?? "子代理", kind: "other",
+            status: state === "failed" || state === "stopped" ? "failed" : state === "completed" ? "completed" : "in_progress",
+            detail: { type: "subagent", action: "spawn", name: association.title, task: association.description, nativeSessionId: childId, canCancel: association.canCancel, state },
+        };
+        this.onMappedUpdate(parent, { sessionUpdate: created ? "tool_call" : "tool_call_update", ...call });
+    }
+    isChildOf(child, parent, seen = new Set()) {
+        if (seen.has(child))
+            return false;
+        seen.add(child);
+        const parents = this.children.get(child);
+        return !!parents && (parents.has(parent) || [...parents.keys()].some((id) => this.isChildOf(id, parent, seen)));
+    }
+    requestOwner(nativeId, requestId) {
+        for (const [id, state] of this.sessions)
+            if ((id === nativeId || this.isChildOf(id, nativeId)) && (state.permissions.has(requestId) || state.questions.has(requestId)))
+                return { id, state };
+        return undefined;
     }
     onUpdate(sessionId, raw) {
-        const update = normalizeAcpUpdate(raw);
-        if (!update)
+        const record = raw;
+        if (record?.sessionUpdate === "notice") {
+            if (!this.sessions.get(sessionId)?.replaying && typeof record.title === "string" && typeof record.severity === "string") {
+                const roots = (id) => this.children.has(id) ? [...this.children.get(id).keys()].flatMap(roots) : [id];
+                for (const root of new Set(roots(sessionId)))
+                    this.host?.notice?.(this.id, root, { severity: record.severity, title: record.title, description: typeof record.description === "string" ? record.description : undefined });
+            }
             return;
+        }
         const state = this.sessions.get(sessionId);
-        if (state?.replaying) {
-            state.replaying.push(update);
+        if (record?.sessionUpdate === "subagent_update" && this.settings().experimental) {
+            this.subagentUpdate(sessionId, raw);
+            return;
+        }
+        const version = this.connection?.protocolVersion ?? 1;
+        if (version === 2 && state && record?.sessionUpdate === "state_update") {
+            const status = raw;
+            for (const parent of this.children.get(sessionId)?.keys() ?? [])
+                this.subagentUpdate(parent, { sessionId, state: status });
+            state.reportedState = status.state === "running" ? "running" : status.state === "requires_action" ? "waiting" : status.state === "idle" ? "idle" : "unknown";
+            if (status.state === "running" || status.state === "requires_action") {
+                if (!state.turnActive && !state.replaying)
+                    this.emit(sessionId, { sessionUpdate: "ls_turn", state: "started" });
+                state.turnActive = true;
+                state.idleReason = undefined;
+            }
+            else if (status.state === "idle") {
+                if (state.replaying)
+                    state.turnActive = false;
+                else if (state.turnActive) {
+                    state.idleReason = toStopReason(status.stopReason);
+                    if (!state.inflight)
+                        this.finishTurn(sessionId, state, state.idleReason);
+                }
+            }
+            const usage = status.usage ? usageUpdate(status.usage) : undefined;
+            if (usage)
+                this.onMappedUpdate(sessionId, usage);
+            if (!state.replaying && !this.children.has(sessionId))
+                this.host?.update(this.id, sessionId, { sessionUpdate: "ls_status", state: this.localState(sessionId), turnActive: state.turnActive });
             return;
         }
+        if (version === 2 && state && record?.sessionUpdate === "user_message" && state.inflight > 0 && !state.replaying) {
+            state.deferredUserUpdates.push(raw);
+            return;
+        }
+        const remapped = version === 2 && raw && typeof raw === "object" && "messageId" in raw && typeof raw.messageId === "string"
+            ? { ...raw, messageId: state?.messageAliases.get(raw.messageId) ?? raw.messageId } : raw;
+        for (const update of state?.updates.map(remapped, version) ?? [normalizeAcpUpdate(remapped)].filter((entry) => !!entry))
+            this.onMappedUpdate(sessionId, update);
+    }
+    onMappedUpdate(sessionId, update) {
+        const state = this.sessions.get(sessionId);
         if (state?.turnActive && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update"))
             state.toolCalls.add(update.toolCallId);
         if (update.sessionUpdate === "current_mode_update" && state) {
@@ -429,11 +902,43 @@ export class AcpDriver {
                 mode.current = update.currentModeId;
         }
         if (update.sessionUpdate === "ls_config" && state) {
-            state.config = update.options.map((option) => ({ ...option, source: "configOptions" }));
+            state.config = this.mergeConfig(state, update.options.map((option) => ({ ...option, source: "configOptions" })));
+            update = { ...update, options: state.config.map(({ source: _source, ...option }) => option) };
+        }
+        if (update.sessionUpdate === "available_commands_update" && state)
+            state.commands = update;
+        if (state?.replaying) {
+            state.replaying.push(update);
+            return;
         }
         this.emit(sessionId, update);
+        if (this.connection?.protocolVersion !== 2 && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update")) {
+            for (const content of update.content ?? []) {
+                if (content.type !== "terminal")
+                    continue;
+                const key = `${sessionId}\n${content.terminalId}`;
+                const calls = this.terminalCalls.get(key) ?? new Set();
+                if (!calls.has(update.toolCallId)) {
+                    calls.add(update.toolCallId);
+                    this.terminalCalls.set(key, calls);
+                    const snapshot = this.services.output(sessionId, content.terminalId);
+                    if (snapshot)
+                        this.emit(sessionId, { sessionUpdate: "tool_call_update", toolCallId: update.toolCallId, replaceOutput: snapshot.output });
+                }
+            }
+        }
     }
     onRequest(method, params, id) {
+        if (method === "mcp/message") {
+            const controller = new AbortController();
+            this.serviceRequests.set(id, controller);
+            return this.mcp.request(params, controller.signal).finally(() => this.serviceRequests.delete(id));
+        }
+        if (method.startsWith("fs/") || method.startsWith("terminal/")) {
+            const controller = new AbortController();
+            this.serviceRequests.set(id, controller);
+            return this.services.request(method, params, controller.signal).finally(() => this.serviceRequests.delete(id));
+        }
         if (questionMethod(this.id, method))
             return this.onQuestions(method, params, id);
         if (method !== "session/request_permission") {
@@ -446,9 +951,9 @@ export class AcpDriver {
         if (!state || !mapped)
             return { outcome: { outcome: "cancelled" } };
         return new Promise((resolve) => {
-            state.permissions.set(requestId, resolve);
+            state.permissions.set(requestId, { rpcId: id, resolve });
             this.closeMessage(sessionId);
-            this.host?.update(this.id, sessionId, mapped.update);
+            this.publish(sessionId, mapped.update);
         });
     }
     /** Questions are routed by explicit session id, then Cursor's tool id, never a "last session". */
@@ -472,6 +977,17 @@ export class AcpDriver {
         throw new RpcError(-32602, "无法确定这个问题属于哪个会话，未提交任何回答");
     }
     onQuestions(method, params, id) {
+        const scope = params;
+        if (method === "elicitation/create" && scope.sessionId === undefined && (typeof scope.requestId === "string" || typeof scope.requestId === "number")) {
+            if (!this.connection?.hasPendingRequest(scope.requestId))
+                throw new RpcError(-32602, "授权请求已经结束");
+            const requestId = `${this.id}-q${this.nextPermissionId++}-${String(id)}`;
+            const request = mapAcpQuestions(this.id, method, params, requestId);
+            return new Promise((resolve) => {
+                this.interactions.set(requestId, { rpcId: id, parentId: scope.requestId, request, resolve });
+                this.host?.interaction?.(this.id, request.update);
+            });
+        }
         const sessionId = this.questionSession(params);
         const state = this.sessions.get(sessionId);
         const requestId = `${this.id}-q${this.nextPermissionId++}-${String(id)}`;
@@ -479,33 +995,50 @@ export class AcpDriver {
         return new Promise((resolve) => {
             state.questions.set(requestId, { rpcId: id, request, resolve });
             this.closeMessage(sessionId);
-            this.host?.update(this.id, sessionId, request.update);
+            this.publish(sessionId, request.update);
         });
     }
     cancelQuestionRequest(id) {
+        this.serviceRequests.get(id)?.abort();
+        for (const [requestId, pending] of this.interactions)
+            if (pending.rpcId === id)
+                this.resolveInteraction(requestId, "cancel");
         for (const [sessionId, state] of this.sessions) {
+            for (const [requestId, pending] of state.permissions) {
+                if (pending.rpcId !== id)
+                    continue;
+                state.permissions.delete(requestId);
+                pending.resolve({ outcome: { outcome: "cancelled" } });
+                this.publish(sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
+            }
             for (const [requestId, pending] of state.questions) {
                 if (pending.rpcId !== id)
                     continue;
                 state.questions.delete(requestId);
                 pending.resolve(pending.request.respond("cancel"));
-                this.host?.update(this.id, sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
+                this.publish(sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
             }
         }
     }
     async answerQuestion(nativeId, requestId, answers) {
-        const state = this.sessions.get(nativeId);
+        const owner = this.requestOwner(nativeId, requestId);
+        const state = owner?.state;
         const pending = state?.questions.get(requestId);
         if (!state || !pending)
             throw RpcError.app("not_found", "这个问题已经不在等回答了");
         const response = pending.request.answer(answers);
         state.questions.delete(requestId);
         pending.resolve(response);
-        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_permission_resolved", requestId, optionId: "answered", answers });
+        const recorded = answers.map((answer) => pending.request.update.questions?.find((question) => question.id === answer.id)?.secret ? { id: answer.id, values: ["••••••"] } : answer);
+        this.publish(owner.id, { sessionUpdate: "ls_permission_resolved", requestId, optionId: "answered", answers: recorded });
     }
     cancelPermissions(state) {
-        for (const resolve of state.permissions.values())
-            resolve({ outcome: { outcome: "cancelled" } });
+        const nativeId = [...this.sessions].find(([, value]) => value === state)?.[0];
+        if (nativeId)
+            for (const requestId of [...state.permissions.keys(), ...state.questions.keys()])
+                this.publish(nativeId, { sessionUpdate: "ls_permission_resolved", requestId });
+        for (const pending of state.permissions.values())
+            pending.resolve({ outcome: { outcome: "cancelled" } });
         state.permissions.clear();
         for (const pending of state.questions.values())
             pending.resolve(pending.request.respond("cancel"));
@@ -521,16 +1054,28 @@ export class AcpDriver {
     }
     startTurn(nativeId, state, content, clientMessageId, context) {
         state.turnActive = true;
+        state.reportedState = undefined;
+        state.idleReason = undefined;
         this.echoUserMessage(nativeId, content, clientMessageId);
         this.emit(nativeId, { sessionUpdate: "ls_turn", state: "started" });
-        void this.sendPrompt(nativeId, state, withContext(toAcpPrompt(content), context));
+        void this.sendPrompt(nativeId, state, withContext(toAcpPrompt(content), context), clientMessageId);
     }
-    async sendPrompt(nativeId, state, prompt) {
+    async sendPrompt(nativeId, state, prompt, clientMessageId) {
         state.inflight += 1;
         let stopReason;
         try {
             const result = await this.rpc("session/prompt", { sessionId: nativeId, prompt }, 0);
-            stopReason = toStopReason(result.stopReason);
+            if (this.connection?.protocolVersion === 2) {
+                if (typeof result.messageId !== "string")
+                    throw new Error("ACP 2 未返回已接收的消息 ID");
+                state.messageAliases.set(result.messageId, `local-${clientMessageId}`);
+                this.host?.state(this.id, nativeId).set("acp-message-aliases", JSON.stringify([...state.messageAliases]));
+            }
+            else
+                stopReason = toStopReason(result.stopReason);
+            const usage = result.usage ? usageUpdate(result.usage) : undefined;
+            if (usage)
+                this.emit(nativeId, usage);
         }
         catch (error) {
             stopReason = "error";
@@ -542,8 +1087,19 @@ export class AcpDriver {
         // A steered prompt settles the earlier one; the turn ends with the last.
         if (state.inflight > 0)
             return;
+        for (const raw of state.deferredUserUpdates.splice(0))
+            this.onUpdate(nativeId, raw);
+        const ended = stopReason ?? state.idleReason;
+        if (ended)
+            this.finishTurn(nativeId, state, ended);
+    }
+    finishTurn(nativeId, state, stopReason) {
+        if (!state.turnActive)
+            return;
         this.closeMessage(nativeId);
         state.turnActive = false;
+        state.reportedState = stopReason === "error" ? "error" : "idle";
+        state.idleReason = undefined;
         state.toolCalls.clear();
         this.cancelPermissions(state);
         this.emit(nativeId, { sessionUpdate: "ls_turn", state: "ended", stopReason });
@@ -553,6 +1109,9 @@ export class AcpDriver {
         if (next && state.loaded)
             this.startTurn(nativeId, state, next.content, next.clientMessageId, next.context);
     }
+    settings() {
+        return this.host?.agentSettings?.(this.id) ?? this.spec.settings ?? acpAgentSettingsSchema.parse({});
+    }
     /** The agent's own delete, when it has one (ACP session/delete). */
     async delete(nativeId) {
         if (!this.connection?.alive)
@@ -603,11 +1162,20 @@ export class AcpDriver {
         }
         const connection = this.connection;
         const opensSession = ["session/new", "session/load", "session/resume", "session/fork"].includes(method);
+        const serverIds = opensSession ? (params.mcpServers ?? []).flatMap((server) => server.type === "acp" && server.serverId ? [server.serverId] : []) : [];
+        let succeeded = false;
+        const bindServers = (result) => {
+            succeeded = true;
+            const sessionId = result?.sessionId ?? params.sessionId;
+            if (sessionId)
+                this.mcp.bind(serverIds, sessionId);
+            return result;
+        };
         try {
             const result = await connection.request(method, params, timeoutMs);
             if (opensSession)
                 this.signedOut = undefined;
-            return result;
+            return bindServers(result);
         }
         catch (error) {
             if (!opensSession)
@@ -631,12 +1199,19 @@ export class AcpDriver {
                 await this.authenticating.promise;
                 const result = await connection.request(method, params, timeoutMs);
                 this.signedOut = undefined;
-                return result;
+                return bindServers(result);
             }
             catch (retryError) {
                 throw this.signInError(retryError);
             }
         }
+        finally {
+            if (!succeeded && serverIds.length)
+                await this.mcp.close(undefined, serverIds);
+            for (const [requestId, pending] of this.interactions)
+                if (!connection.hasPendingRequest(pending.parentId))
+                    this.resolveInteraction(requestId, "cancel");
+        }
     }
 }
 //# sourceMappingURL=driver.js.map