acpx 0.13.0 → 0.13.1

package/dist/{live-checkpoint-CBecfnSH.js → live-checkpoint-BSIrfgVo.js}

@@ -6,9 +6,8 @@ import os from "node:os";
 import { randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, PROTOCOL_VERSION, RequestError } from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION, client, methods } from "@agentclientprotocol/sdk";
 import readline from "node:readline/promises";
-import { promisify } from "node:util";
 //#region src/errors.ts
 var AcpxOperationalError = class extends Error {
 	outputCode;
@@ -1721,7 +1720,8 @@ function assertPersistedKeyPolicy(value) {
 //#endregion
 //#region src/session/persistence/atomic-write.ts
 function createAtomicWriteTempPath(filePath, createUniqueId = randomUUID) {
-	return `${filePath}.${process.pid}.${Date.now()}.${createUniqueId()}.tmp`;
+	const tempName = `.acpx-write.${process.pid}.${Date.now()}.${createUniqueId()}.tmp`;
+	return path.join(path.dirname(filePath), tempName);
 }
 //#endregion
 //#region src/session/persistence/index.ts
@@ -2633,9 +2633,41 @@ function getAcpxVersion() {
 	cachedVersion = resolveAcpxVersion();
 	return cachedVersion;
 }
-//#endregion
-//#region src/acp/client-process.ts
-const execFileAsync = promisify(execFile);
+async function runTimedExecFile(command, args, options = {}) {
+	const timeoutMs = Math.max(1, Math.round(options.timeoutMs ?? 8e3));
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let timer;
+		const child = execFile(command, [...args], {
+			encoding: "utf8",
+			maxBuffer: options.maxBufferBytes ?? 33554432,
+			killSignal: "SIGKILL",
+			windowsHide: options.windowsHide
+		}, (error, stdout) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(stdout);
+		});
+		timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			const killed = child.kill("SIGKILL");
+			child.stdout?.destroy();
+			child.stderr?.destroy();
+			child.unref();
+			reject(Object.assign(/* @__PURE__ */ new Error(`${command} timed out after ${timeoutMs}ms`), {
+				code: "ETIMEDOUT",
+				killed,
+				signal: "SIGKILL"
+			}));
+		}, timeoutMs);
+	});
+}
 function normalizeAgentCommandInput(value) {
 	if (typeof value === "string") return { agentCommand: value };
 	const parts = toCommandParts([...value]);
@@ -2832,8 +2864,7 @@ function isWindowsExecutableCommand(command) {
 	return WINDOWS_EXECUTABLE_EXTENSION_RE.test(normalized);
 }
 async function runWslpath(cwd) {
-	const { stdout } = await execFileAsync("wslpath", ["-w", cwd], { encoding: "utf8" });
-	return stdout;
+	return await runTimedExecFile("wslpath", ["-w", cwd]);
 }
 function basenameToken(value) {
 	return path.basename(value).toLowerCase().replace(/\.(cmd|exe|bat)$/u, "");
@@ -3376,6 +3407,7 @@ var TerminalManager = class {
 	usesDefaultConfirmExecute;
 	confirmExecute;
 	killGraceMs;
+	processHelperTimeoutMs;
 	terminals = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.cwd = options.cwd;
@@ -3385,6 +3417,7 @@ var TerminalManager = class {
 		this.usesDefaultConfirmExecute = options.confirmExecute == null;
 		this.confirmExecute = options.confirmExecute ?? defaultConfirmExecute;
 		this.killGraceMs = Math.max(0, Math.round(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS));
+		this.processHelperTimeoutMs = Math.max(1, Math.round(options.processHelperTimeoutMs ?? 8e3));
 	}
 	updatePermissionPolicy(permissionMode, nonInteractivePermissions) {
 		this.permissionMode = permissionMode;
@@ -3411,6 +3444,7 @@ var TerminalManager = class {
 				process: proc,
 				killProcessGroup: spawnCommand.killProcessGroup,
 				descendantPids: /* @__PURE__ */ new Set(),
+				processHelperTimeoutMs: this.processHelperTimeoutMs,
 				output: Buffer.alloc(0),
 				truncated: false,
 				outputByteLimit,
@@ -3636,7 +3670,7 @@ var TerminalManager = class {
 	}
 	async captureDescendantPids(terminal, pid) {
 		if (!this.isRunning(terminal)) await terminal.processGroupSnapshotPromise?.catch(() => {});
-		for (const descendantPid of await listDescendantPids(pid)) terminal.descendantPids.add(descendantPid);
+		for (const descendantPid of await listDescendantPids(pid, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(descendantPid);
 	}
 	async waitForCleanupAfterSignal(terminal) {
 		return await Promise.race([this.waitForTerminalAndTrackedDescendants(terminal).then(() => true), waitMs(this.killGraceMs).then(() => false)]);
@@ -3689,10 +3723,10 @@ function commandPathExists(command, cwd) {
 	const resolvedPath = path.isAbsolute(command) ? command : path.resolve(cwd, command);
 	return fs.existsSync(resolvedPath);
 }
-async function listDescendantPids(rootPid) {
+async function listDescendantPids(rootPid, timeoutMs) {
 	let output;
 	try {
-		output = await runProcessListCommand();
+		output = await runProcessListCommand(timeoutMs);
 	} catch {
 		return [];
 	}
@@ -3725,47 +3759,23 @@ function parseProcessListLine(line) {
 		parentPid
 	};
 }
-async function runProcessListCommand() {
-	if (process.platform === "win32") return await runWindowsProcessListCommand();
-	return await new Promise((resolve, reject) => {
-		const child = spawn("ps", ["-eo", "pid=,ppid="], { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`ps exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
-	});
+async function runProcessListCommand(timeoutMs) {
+	if (process.platform === "win32") return await runWindowsProcessListCommand(timeoutMs);
+	return await runTimedExecFile("ps", ["-eo", "pid=,ppid="], { timeoutMs });
 }
 async function rememberProcessGroupPids(terminal) {
 	const processGroupId = terminal.process.pid;
 	if (!terminal.killProcessGroup || !processGroupId) return;
 	if (process.platform === "win32") {
-		for (const pid of await listDescendantPids(processGroupId)) terminal.descendantPids.add(pid);
+		for (const pid of await listDescendantPids(processGroupId, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(pid);
 		return;
 	}
-	for (const pid of await listProcessGroupPids(processGroupId)) if (pid !== processGroupId) terminal.descendantPids.add(pid);
+	for (const pid of await listProcessGroupPids(processGroupId, terminal.processHelperTimeoutMs)) if (pid !== processGroupId) terminal.descendantPids.add(pid);
 }
-async function listProcessGroupPids(processGroupId) {
+async function listProcessGroupPids(processGroupId, timeoutMs) {
 	let output;
 	try {
-		output = await runProcessGroupListCommand();
+		output = await runProcessGroupListCommand(timeoutMs);
 	} catch {
 		return [];
 	}
@@ -3779,66 +3789,18 @@ async function listProcessGroupPids(processGroupId) {
 	}
 	return pids;
 }
-async function runProcessGroupListCommand() {
-	return await new Promise((resolve, reject) => {
-		const child = spawn("ps", ["-eo", "pid=,pgid="], { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`ps exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
-	});
-}
-async function runWindowsProcessListCommand() {
-	return await new Promise((resolve, reject) => {
-		const child = spawn("powershell.exe", [
-			"-NoProfile",
-			"-NonInteractive",
-			"-Command",
-			["Get-CimInstance Win32_Process |", "ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"].join(" ")
-		], {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`powershell process list exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
+async function runProcessGroupListCommand(timeoutMs) {
+	return await runTimedExecFile("ps", ["-eo", "pid=,pgid="], { timeoutMs });
+}
+async function runWindowsProcessListCommand(timeoutMs) {
+	return await runTimedExecFile("powershell.exe", [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		["Get-CimInstance Win32_Process |", "ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"].join(" ")
+	], {
+		timeoutMs,
+		windowsHide: true
 	});
 }
 async function killWindowsProcessTree(pid, signal) {
@@ -3898,6 +3860,14 @@ const STARTUP_STDERR_MAX_CHARS = 8192;
 const DEVIN_COMPATIBILITY_CLIENT_CAPABILITIES_META = Object.freeze({ "cognition.ai/requestDiagnostics": true });
 const DEVIN_COMPATIBILITY_CLIENT_NAME = "windsurf";
 const DEFAULT_DEVIN_COMPATIBILITY_CLIENT_VERSION = "1.110.1";
+const ELICITATION_CANCEL_MESSAGES = {
+	inactive: "elicitation owner is no longer active",
+	unavailable: "elicitation handler is unavailable",
+	unsupported: "elicitation mode is not supported",
+	mismatchedSession: "elicitation session is not active",
+	cancelled: "elicitation request was cancelled",
+	requestScoped: "request-scoped elicitation has no owner"
+};
 function resolveClientInfo(devinAcp) {
 	if (!devinAcp) return {
 		name: "acpx",
@@ -3908,13 +3878,88 @@ function resolveClientInfo(devinAcp) {
 		version: process.env.ACPX_DEVIN_WINDSURF_VERSION ?? DEFAULT_DEVIN_COMPATIBILITY_CLIENT_VERSION
 	};
 }
+function normalizeElicitationModes(modes) {
+	return [...new Set((modes ?? []).filter((mode) => mode === "form" || mode === "url"))];
+}
+function cancelledElicitationResponse(message) {
+	return {
+		action: "cancel",
+		_meta: { message }
+	};
+}
+function isKnownElicitationResponse(response) {
+	if (!response || typeof response !== "object") return false;
+	const action = response.action;
+	return action === "accept" || action === "decline" || action === "cancel";
+}
+function elicitationSessionId(request) {
+	const value = request.sessionId;
+	return typeof value === "string" ? value : void 0;
+}
+function elicitationRequestScopeId(request) {
+	const value = request.requestId;
+	return value === null || typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function waitForAbort(signal) {
+	if (signal.aborted) return Promise.resolve({ kind: "aborted" });
+	return new Promise((resolve) => {
+		signal.addEventListener("abort", () => resolve({ kind: "aborted" }), { once: true });
+	});
+}
+function isExtensionNotification(message) {
+	if (!("method" in message) || "id" in message || typeof message.method !== "string") return false;
+	return message.method !== methods.client.session.update && message.method !== methods.client.elicitation.complete && message.method !== methods.protocol.cancelRequest;
+}
+function elicitationRequestId(message) {
+	if (!("method" in message) || message.method !== methods.client.elicitation.create || !("id" in message)) return;
+	return message.id;
+}
+function responseId(message) {
+	if (!("id" in message) || "method" in message) return;
+	return message.id;
+}
+function promptRequestOwner(message) {
+	if (!("method" in message) || message.method !== methods.agent.session.prompt || !("id" in message)) return;
+	const sessionId = message.params?.sessionId;
+	return typeof sessionId === "string" ? {
+		requestId: message.id,
+		sessionId
+	} : void 0;
+}
+function createAgentConnectionFacade(connection) {
+	const agent = connection.agent;
+	return {
+		signal: connection.signal,
+		close: (error) => connection.close(error),
+		initialize: async (params) => await agent.request(methods.agent.initialize, params),
+		authenticate: async (params) => {
+			await agent.request(methods.agent.authenticate, params);
+		},
+		newSession: async (params) => await agent.request(methods.agent.session.new, params),
+		loadSession: async (params) => await agent.request(methods.agent.session.load, params),
+		resumeSession: async (params) => await agent.request(methods.agent.session.resume, params),
+		prompt: async (params) => await agent.request(methods.agent.session.prompt, params),
+		setSessionMode: async (params) => await agent.request(methods.agent.session.setMode, params),
+		setSessionConfigOption: async (params) => await agent.request(methods.agent.session.setConfigOption, params),
+		extMethod: async (method, params) => await agent.request(method, params),
+		cancel: async (params) => await agent.notify(methods.agent.session.cancel, params),
+		closeSession: async (params) => {
+			await agent.request(methods.agent.session.close, params);
+		},
+		listSessions: async (params) => await agent.request(methods.agent.session.list, params)
+	};
+}
 function resolveClientCapabilities(params) {
 	const baseCapabilities = {
 		fs: {
 			readTextFile: params.fs,
 			writeTextFile: params.fs
 		},
-		terminal: params.terminal
+		terminal: params.terminal,
+		...params.elicitationModes.length > 0 ? { elicitation: {
+			...params.elicitationModes.includes("form") ? { form: {} } : {},
+			...params.elicitationModes.includes("url") ? { url: {} } : {}
+		} } : {}
 	};
 	if (!params.devinAcp) return baseCapabilities;
 	return {
@@ -3922,9 +3967,6 @@ function resolveClientCapabilities(params) {
 		_meta: DEVIN_COMPATIBILITY_CLIENT_CAPABILITIES_META
 	};
 }
-function isDevinRequestDiagnosticsMethod(method) {
-	return method === "_cognition.ai/request_diagnostics";
-}
 function hasResponseField(response, field) {
 	return !!response && typeof response === "object" && field in response;
 }
@@ -3945,6 +3987,15 @@ function toReconnectedSessionResult(response) {
 		legacyModelMetadataPresent: hasResponseField(response, "models")
 	};
 }
+function snapshotPermissionPolicy(policy) {
+	if (!policy) return;
+	return {
+		...policy.autoApprove ? { autoApprove: [...policy.autoApprove] } : {},
+		...policy.autoDeny ? { autoDeny: [...policy.autoDeny] } : {},
+		...policy.escalate ? { escalate: [...policy.escalate] } : {},
+		...policy.defaultAction ? { defaultAction: policy.defaultAction } : {}
+	};
+}
 function childProcessIsRunning(agent) {
 	if (!agent) return false;
 	return agent.exitCode == null && agent.signalCode == null && !agent.killed;
@@ -4037,6 +4088,7 @@ var AcpClient = class {
 	suppressSessionUpdates = false;
 	suppressReplaySessionUpdateMessages = false;
 	activePrompt;
+	pendingPromptOwners = [];
 	cancellingSessionIds = /* @__PURE__ */ new Set();
 	permissionAbortControllers = /* @__PURE__ */ new Map();
 	closing = false;
@@ -4051,7 +4103,9 @@ var AcpClient = class {
 		this.options = {
 			...options,
 			cwd: asAbsoluteCwd(options.cwd),
-			authPolicy: options.authPolicy ?? "skip"
+			authPolicy: options.authPolicy ?? "skip",
+			permissionPolicy: snapshotPermissionPolicy(options.permissionPolicy),
+			elicitationModes: normalizeElicitationModes(options.elicitationModes)
 		};
 		this.eventHandlers = {
 			onAcpMessage: this.options.onAcpMessage,
@@ -4118,7 +4172,7 @@ var AcpClient = class {
 		const shouldRefreshPermissionPolicy = options.permissionMode !== void 0 || options.nonInteractivePermissions !== void 0;
 		if (options.permissionMode) this.options.permissionMode = options.permissionMode;
 		if (options.nonInteractivePermissions !== void 0) this.options.nonInteractivePermissions = options.nonInteractivePermissions;
-		if (Object.prototype.hasOwnProperty.call(options, "permissionPolicy")) this.options.permissionPolicy = options.permissionPolicy;
+		if (Object.prototype.hasOwnProperty.call(options, "permissionPolicy")) this.options.permissionPolicy = snapshotPermissionPolicy(options.permissionPolicy);
 		this.updateClientCapabilityPreferences(options);
 		this.refreshRuntimePermissionPolicy(shouldRefreshPermissionPolicy);
 		if (options.suppressSdkConsoleErrors !== void 0) this.options.suppressSdkConsoleErrors = options.suppressSdkConsoleErrors;
@@ -4141,6 +4195,15 @@ var AcpClient = class {
 		if (sessionId == null) return true;
 		return this.activePrompt.sessionId === sessionId;
 	}
+	hasUnresolvedPrompt() {
+		return this.activePrompt !== void 0;
+	}
+	endPromptElicitation(sessionId) {
+		const active = this.activePrompt;
+		if (!active || active.sessionId !== sessionId) return;
+		active.elicitationHandler = void 0;
+		active.elicitationController.abort();
+	}
 	async start() {
 		if (this.connection && this.agent && isChildProcessRunning(this.agent)) return;
 		if (this.connection || this.agent) await this.close();
@@ -4228,42 +4291,31 @@ var AcpClient = class {
 		return requireAgentStdio(spawnedChild);
 	}
 	createConnection(stream, launch) {
-		return new ClientSideConnection(() => ({
-			sessionUpdate: async (params) => {
-				await this.handleSessionUpdate(params);
-			},
-			requestPermission: async (params) => {
-				return this.handlePermissionRequest(params);
-			},
-			extMethod: async (method) => {
-				if (launch.devinAcp && isDevinRequestDiagnosticsMethod(method)) return {};
-				const error = RequestError.methodNotFound(method);
-				if (!this.options.suppressSdkConsoleErrors) console.error(error.message);
-				throw error;
-			},
-			readTextFile: async (params) => {
-				return this.handleReadTextFile(params);
-			},
-			writeTextFile: async (params) => {
-				return this.handleWriteTextFile(params);
-			},
-			createTerminal: async (params) => {
-				return this.handleCreateTerminal(params);
-			},
-			terminalOutput: async (params) => {
-				return this.handleTerminalOutput(params);
-			},
-			waitForTerminalExit: async (params) => {
-				return this.handleWaitForTerminalExit(params);
-			},
-			killTerminal: async (params) => {
-				return this.handleKillTerminal(params);
-			},
-			releaseTerminal: async (params) => {
-				return this.handleReleaseTerminal(params);
-			},
-			extNotification: async () => {}
-		}), stream);
+		const app = client({ name: "acpx" }).onNotification(methods.client.session.update, async ({ params }) => {
+			await this.handleSessionUpdate(params);
+		}).onNotification(methods.client.elicitation.complete, async () => {}).onRequest(methods.client.session.requestPermission, async ({ params }) => {
+			return await this.handlePermissionRequest(params);
+		}).onRequest(methods.client.elicitation.create, async ({ params, requestId, signal }) => {
+			return await this.handleElicitationRequest(params, requestId, signal);
+		}).onRequest(methods.client.fs.readTextFile, async ({ params }) => {
+			return await this.handleReadTextFile(params);
+		}).onRequest(methods.client.fs.writeTextFile, async ({ params }) => {
+			return await this.handleWriteTextFile(params);
+		}).onRequest(methods.client.terminal.create, async ({ params }) => {
+			return await this.handleCreateTerminal(params);
+		}).onRequest(methods.client.terminal.output, async ({ params }) => {
+			return await this.handleTerminalOutput(params);
+		}).onRequest(methods.client.terminal.waitForExit, async ({ params }) => {
+			return await this.handleWaitForTerminalExit(params);
+		}).onRequest(methods.client.terminal.kill, async ({ params }) => {
+			return await this.handleKillTerminal(params);
+		}).onRequest(methods.client.terminal.release, async ({ params }) => {
+			return await this.handleReleaseTerminal(params);
+		});
+		if (launch.devinAcp) app.onRequest("_cognition.ai/request_diagnostics", (params) => {
+			return params && typeof params === "object" && !Array.isArray(params) ? params : {};
+		}, async () => ({}));
+		return createAgentConnectionFacade(app.connect(stream));
 	}
 	async initializeAgentConnection(params) {
 		try {
@@ -4274,6 +4326,7 @@ var AcpClient = class {
 			this.initResult = initResult;
 			this.log(`initialized protocol version ${initResult.protocolVersion}`);
 		} catch (error) {
+			params.connection.close?.(error);
 			await this.handleInitializeFailure(params, error);
 		}
 	}
@@ -4283,7 +4336,8 @@ var AcpClient = class {
 			clientCapabilities: resolveClientCapabilities({
 				devinAcp: launch.devinAcp,
 				fs: this.options.fs !== false,
-				terminal: this.options.terminal !== false
+				terminal: this.options.terminal !== false,
+				elicitationModes: this.options.elicitationModes ?? []
 			}),
 			clientInfo: resolveClientInfo(launch.devinAcp)
 		});
@@ -4306,9 +4360,24 @@ var AcpClient = class {
 	createTappedStream(base) {
 		const onAcpMessage = () => this.eventHandlers.onAcpMessage;
 		const onAcpOutputMessage = () => this.eventHandlers.onAcpOutputMessage;
+		const elicitationRequestIds = /* @__PURE__ */ new Set();
+		const bindPromptOwner = (owner) => {
+			this.bindPromptOwner(owner);
+		};
 		const shouldSuppressInboundReplaySessionUpdate = (message) => {
 			return this.suppressReplaySessionUpdateMessages && isSessionUpdateNotification(message);
 		};
+		const observeInbound = (message) => {
+			const requestId = elicitationRequestId(message);
+			if (requestId !== void 0) {
+				elicitationRequestIds.add(requestId);
+				return;
+			}
+			if (!shouldSuppressInboundReplaySessionUpdate(message)) {
+				onAcpOutputMessage()?.("inbound", message);
+				onAcpMessage()?.("inbound", message);
+			}
+		};
 		return {
 			readable: new ReadableStream({ async start(controller) {
 				const reader = base.readable.getReader();
@@ -4317,10 +4386,8 @@ var AcpClient = class {
 						const { value, done } = await reader.read();
 						if (done) break;
 						if (!value) continue;
-						if (!shouldSuppressInboundReplaySessionUpdate(value)) {
-							onAcpOutputMessage()?.("inbound", value);
-							onAcpMessage()?.("inbound", value);
-						}
+						observeInbound(value);
+						if (isExtensionNotification(value)) continue;
 						controller.enqueue(value);
 					}
 				} finally {
@@ -4329,8 +4396,13 @@ var AcpClient = class {
 				}
 			} }),
 			writable: new WritableStream({ async write(message) {
-				onAcpOutputMessage()?.("outbound", message);
-				onAcpMessage()?.("outbound", message);
+				const promptOwner = promptRequestOwner(message);
+				if (promptOwner) bindPromptOwner(promptOwner);
+				const id = responseId(message);
+				if (!(id !== void 0 && elicitationRequestIds.delete(id))) {
+					onAcpOutputMessage()?.("outbound", message);
+					onAcpMessage()?.("outbound", message);
+				}
 				const writer = base.writable.getWriter();
 				try {
 					await writer.write(message);
@@ -4426,24 +4498,23 @@ var AcpClient = class {
 		this.suppressSessionUpdates = previous.suppressSessionUpdates;
 		this.suppressReplaySessionUpdateMessages = previous.suppressReplaySessionUpdateMessages;
 	}
-	async prompt(sessionId, prompt) {
+	async prompt(sessionId, prompt, onRequestStarted, onElicitation) {
 		const connection = this.getConnection();
 		const normalizedPrompt = this.normalizePromptForAgent(prompt);
 		const restoreConsoleError = this.options.suppressSdkConsoleErrors ? installSdkConsoleErrorSuppression() : void 0;
+		const activePrompt = this.beginActivePrompt(sessionId, onElicitation);
 		let promptPromise;
 		try {
 			promptPromise = this.runConnectionRequest(() => connection.prompt({
 				sessionId,
 				prompt: normalizedPrompt
-			}));
+			}), onRequestStarted, () => !connection.signal?.aborted);
 		} catch (error) {
+			this.clearActivePrompt(activePrompt);
 			restoreConsoleError?.();
 			throw error;
 		}
-		this.activePrompt = {
-			sessionId,
-			promise: promptPromise
-		};
+		activePrompt.promise = promptPromise;
 		try {
 			return this.returnPromptResponseOrPermissionFailure(sessionId, await promptPromise);
 		} catch (error) {
@@ -4451,12 +4522,37 @@ var AcpClient = class {
 			throw error;
 		} finally {
 			restoreConsoleError?.();
-			if (this.activePrompt?.promise === promptPromise) this.activePrompt = void 0;
+			this.clearActivePrompt(activePrompt);
 			this.cancellingSessionIds.delete(sessionId);
 			this.abortAndDropPermissionSignal(sessionId);
 			this.promptPermissionFailures.delete(sessionId);
 		}
 	}
+	beginActivePrompt(sessionId, elicitationHandler) {
+		const previous = this.activePrompt;
+		this.cancellingSessionIds.delete(sessionId);
+		const active = {
+			sessionId,
+			elicitationHandler,
+			elicitationController: new AbortController()
+		};
+		this.activePrompt = active;
+		this.pendingPromptOwners.push(active);
+		previous?.elicitationController?.abort();
+		return active;
+	}
+	bindPromptOwner(owner) {
+		const active = this.pendingPromptOwners.find((candidate) => {
+			return candidate.requestId === void 0 && candidate.sessionId === owner.sessionId;
+		});
+		if (active) active.requestId = owner.requestId;
+	}
+	clearActivePrompt(active) {
+		if (this.activePrompt === active) this.activePrompt = void 0;
+		const pendingIndex = this.pendingPromptOwners.indexOf(active);
+		if (pendingIndex >= 0) this.pendingPromptOwners.splice(pendingIndex, 1);
+		active.elicitationController.abort();
+	}
 	normalizePromptForAgent(prompt) {
 		const normalizedPrompt = typeof prompt === "string" ? textPrompt(prompt) : prompt;
 		const unsupportedPromptContent = getUnsupportedPromptContentMessage(normalizedPrompt, this.initResult?.agentCapabilities);
@@ -4569,12 +4665,18 @@ var AcpClient = class {
 	}
 	async cancel(sessionId) {
 		const connection = this.getConnection();
-		this.cancellingSessionIds.add(sessionId);
+		const active = this.activePrompt;
+		if (active?.sessionId === sessionId) {
+			this.cancellingSessionIds.add(sessionId);
+			active.elicitationController?.abort();
+		} else this.cancellingSessionIds.delete(sessionId);
 		this.abortAndDropPermissionSignal(sessionId);
 		await this.runConnectionRequest(() => connection.cancel({ sessionId }));
 	}
 	async closeSession(sessionId) {
 		const connection = this.getConnection();
+		this.cancellingSessionIds.add(sessionId);
+		if (this.activePrompt?.sessionId === sessionId) this.activePrompt.elicitationController?.abort();
 		await this.runConnectionRequest(() => connection.closeSession({ sessionId }));
 		if (this.loadedSessionId === sessionId) this.loadedSessionId = void 0;
 		this.modelConfigIds.delete(sessionId);
@@ -4600,21 +4702,25 @@ var AcpClient = class {
 			this.log(`failed to send session/cancel: ${message}`);
 		}
 		if (waitMs <= 0) return;
+		const activePromise = active.promise;
+		if (!activePromise) return;
 		let timer;
 		const timeoutPromise = new Promise((resolve) => {
 			timer = setTimeout(resolve, waitMs);
 		});
 		try {
-			return await Promise.race([active.promise.then((response) => response, () => void 0), timeoutPromise]);
+			return await Promise.race([activePromise.then((response) => response, () => void 0), timeoutPromise]);
 		} finally {
 			if (timer) clearTimeout(timer);
 		}
 	}
 	async close() {
 		this.closing = true;
+		this.abortActiveElicitation();
 		await this.terminalManager.shutdown();
 		const agent = this.agent;
 		if (agent) await this.terminateAgentProcess(agent);
+		this.closeConnection();
 		if (this.pendingConnectionRequests.size > 0) this.rejectPendingConnectionRequests(this.lastAgentExit ? new AgentDisconnectedError(this.lastAgentExit.reason, this.lastAgentExit.exitCode, this.lastAgentExit.signal, { outputAlreadyEmitted: Boolean(this.activePrompt) }) : new AgentDisconnectedError("connection_close", null, null, { outputAlreadyEmitted: Boolean(this.activePrompt) }));
 		this.sessionUpdateChain = Promise.resolve();
 		this.observedSessionUpdates = 0;
@@ -4622,6 +4728,7 @@ var AcpClient = class {
 		this.suppressSessionUpdates = false;
 		this.suppressReplaySessionUpdateMessages = false;
 		this.activePrompt = void 0;
+		this.pendingPromptOwners.length = 0;
 		this.cancellingSessionIds.clear();
 		for (const controller of this.permissionAbortControllers.values()) controller.abort();
 		this.permissionAbortControllers.clear();
@@ -4633,6 +4740,12 @@ var AcpClient = class {
 		this.connection = void 0;
 		this.agent = void 0;
 	}
+	abortActiveElicitation() {
+		this.activePrompt?.elicitationController?.abort();
+	}
+	closeConnection() {
+		this.connection?.close?.();
+	}
 	async terminateAgentProcess(child) {
 		const stdinCloseGraceMs = resolveAgentCloseAfterStdinEndMs(this.options.agentCommand);
 		this.endAgentStdin(child);
@@ -4791,12 +4904,12 @@ var AcpClient = class {
 		const { command, args } = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
 		return command.replace(/\\/g, "/").split("/").pop()?.replace(/\.(cmd|exe|ps1)$/iu, "").toLowerCase() === "grok" && args[0] === "agent" && args[1] === "stdio";
 	}
-	async authenticateIfRequired(connection, methods) {
-		if (methods.length === 0) return;
-		const selected = this.selectAuthMethod(methods);
+	async authenticateIfRequired(connection, authMethods) {
+		if (authMethods.length === 0) return;
+		const selected = this.selectAuthMethod(authMethods);
 		if (!selected) {
-			if (this.options.authPolicy === "fail") throw new AuthPolicyError(`agent advertised auth methods [${methods.map((m) => m.id).join(", ")}] but no matching credentials found`);
-			this.log(`agent advertised auth methods [${methods.map((m) => m.id).join(", ")}] but no matching credentials found — skipping (agent may handle auth internally)`);
+			if (this.options.authPolicy === "fail") throw new AuthPolicyError(`agent advertised auth methods [${authMethods.map((m) => m.id).join(", ")}] but no matching credentials found`);
+			this.log(`agent advertised auth methods [${authMethods.map((m) => m.id).join(", ")}] but no matching credentials found — skipping (agent may handle auth internally)`);
 			return;
 		}
 		await connection.authenticate({ methodId: selected.methodId });
@@ -4813,6 +4926,50 @@ var AcpClient = class {
 		}
 		return response;
 	}
+	async handleElicitationRequest(request, requestId, requestSignal) {
+		const resolved = this.resolveElicitationOwner(request);
+		if ("response" in resolved) return resolved.response;
+		const { active, handler } = resolved.owner;
+		const signal = AbortSignal.any([requestSignal, active.elicitationController.signal]);
+		const handlerAttempt = Promise.resolve().then(async () => await handler(request, {
+			requestId,
+			signal
+		})).then((response) => ({
+			kind: "response",
+			response
+		}), (error) => ({
+			kind: "error",
+			error
+		}));
+		const outcome = await Promise.race([handlerAttempt, waitForAbort(signal)]);
+		if (this.activePrompt !== active) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.inactive);
+		if (outcome.kind === "aborted" || signal.aborted) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.cancelled);
+		if (outcome.kind === "error" || !isKnownElicitationResponse(outcome.response)) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unavailable);
+		return outcome.response;
+	}
+	resolveElicitationOwner(request) {
+		if (!this.options.elicitationModes?.includes(request.mode)) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unsupported) };
+		const active = this.activePrompt;
+		if (!active) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.inactive) };
+		const scope = this.resolveElicitationScope(request, active);
+		if ("response" in scope) return scope;
+		if (this.isElicitationSessionCancelling(scope.sessionId)) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.cancelled) };
+		if (!active.elicitationHandler) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unavailable) };
+		return { owner: {
+			active,
+			handler: active.elicitationHandler
+		} };
+	}
+	resolveElicitationScope(request, active) {
+		const sessionId = elicitationSessionId(request);
+		if (sessionId) return sessionId === active.sessionId ? { sessionId } : { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.mismatchedSession) };
+		const requestScopeId = elicitationRequestScopeId(request);
+		if (requestScopeId === void 0 || requestScopeId !== active.requestId) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.requestScoped) };
+		return { sessionId: active.sessionId };
+	}
+	isElicitationSessionCancelling(sessionId) {
+		return this.closing || this.cancellingSessionIds.has(sessionId);
+	}
 	async tryHandlePermissionRequestWithHost(params) {
 		if (!this.options.onPermissionRequest) return;
 		const signal = this.cancellationSignalForSession(params.sessionId);
@@ -4898,7 +5055,7 @@ var AcpClient = class {
 		if (error) this.promptPermissionFailures.delete(sessionId);
 		return error;
 	}
-	async runConnectionRequest(run) {
+	async runConnectionRequest(run, onRequestStarted, canStartRequest = () => true) {
 		return await new Promise((resolve, reject) => {
 			const pending = {
 				settled: false,
@@ -4911,7 +5068,20 @@ var AcpClient = class {
 				cb();
 			};
 			this.pendingConnectionRequests.add(pending);
-			Promise.resolve().then(run).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+			Promise.resolve().then(async () => {
+				if (pending.settled) return { started: false };
+				const requestCanStart = canStartRequest();
+				const request = run();
+				if (requestCanStart) try {
+					Promise.resolve(onRequestStarted?.()).catch(() => {});
+				} catch {}
+				return {
+					started: true,
+					value: await request
+				};
+			}).then((outcome) => {
+				if (outcome.started) finish(() => resolve(outcome.value));
+			}, (error) => finish(() => reject(error)));
 		});
 	}
 	rejectPendingConnectionRequests(error) {
@@ -6178,35 +6348,24 @@ function createActiveSessionController(params) {
 }
 async function withConnectedSession(options) {
 	const record = await options.loadRecord(options.sessionRecordId);
-	const client = options.createClient?.({
+	const clientOptions = {
 		agentCommand: record.agentCommand,
 		agentArgv: record.agentArgv,
 		cwd: absolutePath(record.cwd),
 		mcpServers: options.mcpServers,
 		permissionMode: options.permissionMode ?? "approve-reads",
 		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
 		onPermissionRequest: options.onPermissionRequest,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
 		fs: options.fs,
 		terminal: options.terminal,
+		elicitationModes: options.elicitationModes,
 		verbose: options.verbose,
 		sessionOptions: sessionOptionsFromRecord(record)
-	}) ?? new AcpClient({
-		agentCommand: record.agentCommand,
-		agentArgv: record.agentArgv,
-		cwd: absolutePath(record.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode ?? "approve-reads",
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		onPermissionRequest: options.onPermissionRequest,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		terminal: options.terminal,
-		verbose: options.verbose,
-		sessionOptions: sessionOptionsFromRecord(record)
-	});
+	};
+	const client = options.createClient?.(clientOptions) ?? new AcpClient(clientOptions);
 	let activeSessionIdForControl = record.acpSessionId;
 	let notifiedClientAvailable = false;
 	const activeController = createActiveSessionController({
@@ -6278,7 +6437,7 @@ const SESSION_REPLY_IDLE_MS = 1e3;
 const SESSION_REPLY_DRAIN_TIMEOUT_MS = 5e3;
 async function runPromptTurn(params) {
 	try {
-		const promptPromise = params.client.prompt(params.sessionId, params.prompt);
+		const promptPromise = params.client.prompt(params.sessionId, params.prompt, params.onPromptRequestStarted, params.onElicitation);
 		await params.onPromptStarted?.();
 		const response = await withTimeout(promptPromise, params.timeoutMs);
 		await params.client.waitForSessionUpdatesIdle?.({
@@ -6357,6 +6516,6 @@ var LiveSessionCheckpoint = class {
 	}
 };
 //#endregion
-export { createAtomicWriteTempPath as $, SESSION_RECORD_SCHEMA as $t, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as A, withInterrupt as At, permissionModeSatisfies as B, isRetryablePromptError as Bt, mergeSessionOptions as C, isPromptInput as Ct, applyLifecycleSnapshotToRecord as D, textPrompt as Dt, applyConversation as E, promptToDisplayText as Et, modelStateFromConfigOptions as F, resolveAgentArgv as Ft, findSessionByDirectoryWalk as G, AUTH_POLICIES as Gt, absolutePath as H, extractAcpError as Ht, normalizeAgentCommandInput as I, resolveAgentCommand as It, listSessionsForAgent as J, OUTPUT_ERROR_CODES as Jt, isoNow$2 as K, EXIT_CODES as Kt, renderArgvIdentity as L, resolveCanonicalAgentName as Lt, RequestedModelUnsupportedError as M, DEFAULT_AGENT_NAME as Mt, assertRequestedModelSupported as N, listBuiltInAgents as Nt, reconcileAgentSessionId as O, InterruptedError as Ot, isRequestedModelUnsupportedError as P, normalizeAgentName$1 as Pt, writeSessionRecord as Q, PERMISSION_POLICY_ACTIONS as Qt, splitCommandLine as R, exitCodeForOutputErrorCode as Rt, advertisedModelState as S, PromptInputValidationError as St, sessionOptionsFromRecord as T, parsePromptSource as Tt, findGitRepositoryRoot as U, isAcpResourceNotFoundError as Ut, DEFAULT_HISTORY_LIMIT as V, normalizeOutputError as Vt, findSession as W, toAcpErrorPayload as Wt, pruneSessions as X, OUTPUT_FORMATS as Xt, normalizeName as Y, OUTPUT_ERROR_ORIGINS as Yt, resolveSessionRecord as Z, PERMISSION_MODES as Zt, createSessionConversation as _, sessionEventSegmentPath as _t, applyRequestedModelIfAdvertised as a, recordPerfDuration as at, recordSessionUpdate as b, parseJsonRpcErrorMessage as bt, setCurrentModelId as c, startPerfTimer as ct, setDesiredModelId as d, normalizeRuntimeSessionId as dt, AcpxOperationalError as en, assertPersistedKeyPolicy as et, syncAdvertisedModelState as f, DEFAULT_EVENT_SEGMENT_MAX_BYTES as ft, cloneSessionConversation as g, sessionEventLockPath as gt, cloneSessionAcpxState as h, sessionEventActivePath as ht, connectAndLoadSession as i, measurePerf as it, REQUESTED_MODEL_UNSUPPORTED_REASONS as j, withTimeout as jt, AcpClient as k, TimeoutError as kt, setDesiredConfigOption as l, parseSessionRecord as lt, applyConfigOptionsToState as m, sessionBaseDir$1 as mt, runPromptTurn as n, QueueConnectionError as nn, getPerfMetricsSnapshot as nt, currentModelIdFromSetModelResponse as o, resetPerfMetrics as ot, applyConfigOptionsToRecord as p, defaultSessionEventLog as pt, listSessions as q, NON_INTERACTIVE_PERMISSION_POLICIES as qt, withConnectedSession as r, QueueProtocolError as rn, incrementPerfCounter as rt, clearDesiredConfigOption as s, setPerfGauge as st, LiveSessionCheckpoint as t, AgentSpawnError as tn, formatPerfMetric as tt, setDesiredModeId as u, serializeSessionRecordForDisk as ut, recordClientOperation as v, extractSessionUpdateNotification as vt, persistSessionOptions as w, mergePromptSourceWithText as wt, trimConversationForRuntime as x, parsePromptStopReason as xt, recordPromptSubmission as y, isAcpJsonRpcMessage as yt, getAcpxVersion as z, formatErrorMessage as zt };
+export { writeSessionRecord as $, PERMISSION_POLICY_ACTIONS as $t, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as A, TimeoutError as At, getAcpxVersion as B, formatErrorMessage as Bt, mergeSessionOptions as C, PromptInputValidationError as Ct, applyLifecycleSnapshotToRecord as D, promptToDisplayText as Dt, applyConversation as E, parsePromptSource as Et, modelStateFromConfigOptions as F, normalizeAgentName$1 as Ft, findSession as G, toAcpErrorPayload as Gt, DEFAULT_HISTORY_LIMIT as H, normalizeOutputError as Ht, normalizeAgentCommandInput as I, resolveAgentArgv as It, listSessions as J, NON_INTERACTIVE_PERMISSION_POLICIES as Jt, findSessionByDirectoryWalk as K, AUTH_POLICIES as Kt, renderArgvIdentity as L, resolveAgentCommand as Lt, RequestedModelUnsupportedError as M, withTimeout as Mt, assertRequestedModelSupported as N, DEFAULT_AGENT_NAME as Nt, reconcileAgentSessionId as O, textPrompt as Ot, isRequestedModelUnsupportedError as P, listBuiltInAgents as Pt, resolveSessionRecord as Q, PERMISSION_MODES as Qt, runTimedExecFile as R, resolveCanonicalAgentName as Rt, advertisedModelState as S, parsePromptStopReason as St, sessionOptionsFromRecord as T, mergePromptSourceWithText as Tt, absolutePath as U, extractAcpError as Ut, permissionModeSatisfies as V, isRetryablePromptError as Vt, findGitRepositoryRoot as W, isAcpResourceNotFoundError as Wt, normalizeName as X, OUTPUT_ERROR_ORIGINS as Xt, listSessionsForAgent as Y, OUTPUT_ERROR_CODES as Yt, pruneSessions as Z, OUTPUT_FORMATS as Zt, createSessionConversation as _, sessionEventLockPath as _t, applyRequestedModelIfAdvertised as a, measurePerf as at, recordSessionUpdate as b, isAcpJsonRpcMessage as bt, setCurrentModelId as c, setPerfGauge as ct, setDesiredModelId as d, serializeSessionRecordForDisk as dt, SESSION_RECORD_SCHEMA as en, createAtomicWriteTempPath as et, syncAdvertisedModelState as f, normalizeRuntimeSessionId as ft, cloneSessionConversation as g, sessionEventActivePath as gt, cloneSessionAcpxState as h, sessionBaseDir$1 as ht, connectAndLoadSession as i, QueueProtocolError as in, incrementPerfCounter as it, REQUESTED_MODEL_UNSUPPORTED_REASONS as j, withInterrupt as jt, AcpClient as k, InterruptedError as kt, setDesiredConfigOption as l, startPerfTimer as lt, applyConfigOptionsToState as m, defaultSessionEventLog as mt, runPromptTurn as n, AgentSpawnError as nn, formatPerfMetric as nt, currentModelIdFromSetModelResponse as o, recordPerfDuration as ot, applyConfigOptionsToRecord as p, DEFAULT_EVENT_SEGMENT_MAX_BYTES as pt, isoNow$2 as q, EXIT_CODES as qt, withConnectedSession as r, QueueConnectionError as rn, getPerfMetricsSnapshot as rt, clearDesiredConfigOption as s, resetPerfMetrics as st, LiveSessionCheckpoint as t, AcpxOperationalError as tn, assertPersistedKeyPolicy as tt, setDesiredModeId as u, parseSessionRecord as ut, recordClientOperation as v, sessionEventSegmentPath as vt, persistSessionOptions as w, isPromptInput as wt, trimConversationForRuntime as x, parseJsonRpcErrorMessage as xt, recordPromptSubmission as y, extractSessionUpdateNotification as yt, splitCommandLine as z, exitCodeForOutputErrorCode as zt };
 
-//# sourceMappingURL=live-checkpoint-CBecfnSH.js.map
+//# sourceMappingURL=live-checkpoint-BSIrfgVo.js.map