acpx 0.3.1 → 0.4.1

package/dist/{session-C2Q8ktsN.js → session-RO_LZUnv.js}

@@ -1,16 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
-import { B as CopilotAcpUnsupportedError, E as normalizeOutputError, F as promptToDisplayText, G as SessionModeReplayError, H as PermissionDeniedError, I as textPrompt, J as extractAcpError, K as SessionNotFoundError, L as AgentSpawnError, R as AuthPolicyError, S as startPerfTimer, T as isAcpQueryClosedBeforeResponseError, U as PermissionPromptUnavailableError, V as GeminiAcpStartupTimeoutError, W as QueueConnectionError, Y as isAcpResourceNotFoundError, _ as getPerfMetricsSnapshot, a as trySetConfigOptionOnRunningOwner, b as resetPerfMetrics, c as SessionQueueOwner, d as releaseQueueOwnerLease, f as terminateProcess, g as formatPerfMetric, h as waitMs$1, i as tryCancelOnRunningOwner, j as SESSION_RECORD_SCHEMA, l as isProcessAlive, m as tryAcquireQueueOwnerLease, o as trySetModeOnRunningOwner, p as terminateQueueOwnerForSession, q as SessionResolutionError, s as trySubmitToRunningOwner, u as refreshQueueOwnerLease, v as incrementPerfCounter, w as formatErrorMessage, x as setPerfGauge, y as measurePerf, z as ClaudeAcpSessionCreateTimeoutError } from "./queue-ipc-EQLpBMKv.js";
-import { n as isSessionUpdateNotification, t as isAcpJsonRpcMessage } from "./acp-jsonrpc-BNHXq7qK.js";
-import { n as normalizeRuntimeSessionId, t as extractRuntimeSessionId } from "./runtime-session-id-C544sPPL.js";
+import { $ as extractAcpError, B as AgentSpawnError, C as formatErrorMessage, E as normalizeOutputError, G as PermissionDeniedError, H as ClaudeAcpSessionCreateTimeoutError, J as SessionModeReplayError, K as PermissionPromptUnavailableError, L as promptToDisplayText, M as extractRuntimeSessionId, N as normalizeRuntimeSessionId, Q as SessionResumeRequiredError, R as textPrompt, T as isRetryablePromptError, U as CopilotAcpUnsupportedError, V as AuthPolicyError, W as GeminiAcpStartupTimeoutError, X as SessionNotFoundError, Y as SessionModelReplayError, Z as SessionResolutionError, _ as incrementPerfCounter, a as trySubmitToRunningOwner, b as setPerfGauge, c as isProcessAlive, d as terminateProcess, et as isAcpResourceNotFoundError, f as terminateQueueOwnerForSession, g as getPerfMetricsSnapshot, h as formatPerfMetric, i as trySetModelOnRunningOwner, j as SESSION_RECORD_SCHEMA, l as refreshQueueOwnerLease, m as waitMs$1, n as trySetConfigOptionOnRunningOwner, o as SessionQueueOwner, p as tryAcquireQueueOwnerLease, q as QueueConnectionError, r as trySetModeOnRunningOwner, t as tryCancelOnRunningOwner, u as releaseQueueOwnerLease, v as measurePerf, w as isAcpQueryClosedBeforeResponseError, x as startPerfTimer, y as resetPerfMetrics, z as AgentDisconnectedError } from "./queue-ipc-CE8_QGX3.js";
+import { n as isAcpJsonRpcMessage, r as isSessionUpdateNotification } from "./acp-jsonrpc-BbBgC5gO.js";
 import fs, { realpathSync, statSync } from "node:fs";
 import fs$1 from "node:fs/promises";
 import path from "node:path";
+import os from "node:os";
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream } from "@agentclientprotocol/sdk";
+import { ClientSideConnection, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 import readline from "node:readline/promises";
 import { randomUUID } from "node:crypto";
-import os from "node:os";
 //#region src/permission-prompt.ts
 async function promptForPermission(options) {
 	if (!process.stdin.isTTY || !process.stderr.isTTY) return false;
@@ -159,8 +158,7 @@ var FileSystemHandlers = class {
 	sliceContent(content, line, limit) {
 		if (line == null && limit == null) return content;
 		const lines = content.split("\n");
-		const startLine = line == null ? 1 : Math.max(1, Math.trunc(line));
-		const startIndex = Math.max(0, startLine - 1);
+		const startIndex = Math.max(0, (line == null ? 1 : Math.max(1, Math.trunc(line))) - 1);
 		const maxLines = limit == null ? void 0 : Math.max(0, Math.trunc(limit));
 		if (maxLines === 0) return "";
 		const endIndex = maxLines == null ? lines.length : Math.min(lines.length, startIndex + maxLines);
@@ -176,6 +174,11 @@ var FileSystemHandlers = class {
 };
 //#endregion
 //#region src/permissions.ts
+const PERMISSION_MODE_RANK = {
+	"deny-all": 0,
+	"approve-reads": 1,
+	"approve-all": 2
+};
 function selected(optionId) {
 	return { outcome: {
 		outcome: "selected",
@@ -216,6 +219,9 @@ async function promptForToolPermission(params) {
 function canPromptForPermission$1() {
 	return Boolean(process.stdin.isTTY && process.stderr.isTTY);
 }
+function permissionModeSatisfies(actual, required) {
+	return PERMISSION_MODE_RANK[actual] >= PERMISSION_MODE_RANK[required];
+}
 async function resolvePermissionRequest(params, mode, nonInteractivePolicy = "deny") {
 	const options = params.options ?? [];
 	if (options.length === 0) return cancelled();
@@ -284,24 +290,64 @@ async function withInterrupt(run, onInterrupt) {
 			settled = true;
 			process.off("SIGINT", onSigint);
 			process.off("SIGTERM", onSigterm);
+			process.off("SIGHUP", onSighup);
 			cb();
 		};
-		const onSigint = () => {
+		const rejectInterrupted = () => {
 			onInterrupt().finally(() => {
 				finish(() => reject(new InterruptedError()));
 			});
 		};
+		const onSigint = () => {
+			rejectInterrupted();
+		};
 		const onSigterm = () => {
-			onInterrupt().finally(() => {
-				finish(() => reject(new InterruptedError()));
-			});
+			rejectInterrupted();
+		};
+		const onSighup = () => {
+			rejectInterrupted();
 		};
 		process.once("SIGINT", onSigint);
 		process.once("SIGTERM", onSigterm);
+		process.once("SIGHUP", onSighup);
 		run().then((result) => finish(() => resolve(result)), (error) => finish(() => reject(error)));
 	});
 }
 //#endregion
+//#region src/spawn-command-options.ts
+function readWindowsEnvValue(env, key) {
+	const matchedKey = Object.keys(env).find((entry) => entry.toUpperCase() === key);
+	return matchedKey ? env[matchedKey] : void 0;
+}
+function resolveWindowsCommand(command, env = process.env) {
+	const extensions = (readWindowsEnvValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+	const candidates = path.extname(command).length > 0 ? [command] : extensions.map((extension) => `${command}${extension}`);
+	if (command.includes("/") || command.includes("\\") || path.isAbsolute(command)) return candidates.find((candidate) => fs.existsSync(candidate));
+	const pathValue = readWindowsEnvValue(env, "PATH");
+	if (!pathValue) return;
+	for (const directory of pathValue.split(";")) {
+		const trimmedDirectory = directory.trim();
+		if (trimmedDirectory.length === 0) continue;
+		for (const candidate of candidates) {
+			const resolved = path.join(trimmedDirectory, candidate);
+			if (fs.existsSync(resolved)) return resolved;
+		}
+	}
+}
+function shouldUseWindowsBatchShell(command, platform = process.platform, env = process.env) {
+	if (platform !== "win32") return false;
+	const resolvedCommand = resolveWindowsCommand(command, env) ?? command;
+	const ext = path.extname(resolvedCommand).toLowerCase();
+	return ext === ".cmd" || ext === ".bat";
+}
+function buildSpawnCommandOptions(command, options, platform = process.platform, env = process.env) {
+	if (!shouldUseWindowsBatchShell(command, platform, env)) return options;
+	return {
+		...options,
+		shell: true
+	};
+}
+//#endregion
 //#region src/terminal.ts
 const DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES = 64 * 1024;
 const DEFAULT_KILL_GRACE_MS = 1500;
@@ -318,17 +364,18 @@ function toEnvObject(env) {
 	for (const entry of env) merged[entry.name] = entry.value;
 	return merged;
 }
-function buildTerminalSpawnOptions(cwd, env) {
-	return {
+function buildTerminalSpawnOptions(command, cwd, env, platform = process.platform) {
+	const resolvedEnv = toEnvObject(env);
+	return buildSpawnCommandOptions(command, {
 		cwd,
-		env: toEnvObject(env),
+		env: resolvedEnv,
 		stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
 		],
 		windowsHide: true
-	};
+	}, platform, resolvedEnv ?? process.env);
 }
 function trimToUtf8Boundary(buffer, limit) {
 	if (limit <= 0) return Buffer.alloc(0);
@@ -397,7 +444,7 @@ var TerminalManager = class {
 		try {
 			if (!await this.isExecuteApproved(commandLine)) throw new PermissionDeniedError("Permission denied for terminal/create");
 			const outputByteLimit = Math.max(0, Math.round(params.outputByteLimit ?? DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES));
-			const proc = spawn(params.command, params.args ?? [], buildTerminalSpawnOptions(params.cwd ?? this.cwd, params.env));
+			const proc = spawn(params.command, params.args ?? [], buildTerminalSpawnOptions(params.command, params.cwd ?? this.cwd, params.env));
 			await waitForSpawn$1(proc);
 			let resolveExit = () => {};
 			const exitPromise = new Promise((resolve) => {
@@ -602,7 +649,8 @@ var TerminalManager = class {
 const REPLAY_IDLE_MS = 80;
 const REPLAY_DRAIN_TIMEOUT_MS = 5e3;
 const DRAIN_POLL_INTERVAL_MS = 20;
-const AGENT_CLOSE_AFTER_STDIN_END_MS = 100;
+const DEFAULT_AGENT_CLOSE_AFTER_STDIN_END_MS = 100;
+const QODER_AGENT_CLOSE_AFTER_STDIN_END_MS = 750;
 const AGENT_CLOSE_TERM_GRACE_MS = 1500;
 const AGENT_CLOSE_KILL_GRACE_MS = 1e3;
 const GEMINI_ACP_STARTUP_TIMEOUT_MS = 15e3;
@@ -615,6 +663,7 @@ const GEMINI_ACP_FLAG_VERSION = [
 ];
 const COPILOT_HELP_TIMEOUT_MS = 2e3;
 const SESSION_CONTROL_UNSUPPORTED_ACP_CODES = new Set([-32601, -32602]);
+const QODER_BENIGN_STDOUT_LINES = new Set(["Received interrupt signal. Cleaning up resources...", "Cleanup completed. Exiting..."]);
 function shouldSuppressSdkConsoleError(args) {
 	if (args.length === 0) return false;
 	return typeof args[0] === "string" && args[0] === "Error handling request";
@@ -723,6 +772,56 @@ function asAbsoluteCwd(cwd) {
 function basenameToken(value) {
 	return path.basename(value).toLowerCase().replace(/\.(cmd|exe|bat)$/u, "");
 }
+function resolveAgentCloseAfterStdinEndMs(agentCommand) {
+	const { command } = splitCommandLine(agentCommand);
+	return basenameToken(command) === "qodercli" ? QODER_AGENT_CLOSE_AFTER_STDIN_END_MS : DEFAULT_AGENT_CLOSE_AFTER_STDIN_END_MS;
+}
+function shouldIgnoreNonJsonAgentOutputLine(agentCommand, trimmedLine) {
+	const { command } = splitCommandLine(agentCommand);
+	return basenameToken(command) === "qodercli" && QODER_BENIGN_STDOUT_LINES.has(trimmedLine);
+}
+function createNdJsonMessageStream(agentCommand, output, input) {
+	const textEncoder = new TextEncoder();
+	const textDecoder = new TextDecoder();
+	return {
+		readable: new ReadableStream({ async start(controller) {
+			let content = "";
+			const reader = input.getReader();
+			try {
+				while (true) {
+					const { value, done } = await reader.read();
+					if (done) break;
+					if (!value) continue;
+					content += textDecoder.decode(value, { stream: true });
+					const lines = content.split("\n");
+					content = lines.pop() || "";
+					for (const line of lines) {
+						const trimmedLine = line.trim();
+						if (!trimmedLine || shouldIgnoreNonJsonAgentOutputLine(agentCommand, trimmedLine)) continue;
+						try {
+							const message = JSON.parse(trimmedLine);
+							controller.enqueue(message);
+						} catch (err) {
+							console.error("Failed to parse JSON message:", trimmedLine, err);
+						}
+					}
+				}
+			} finally {
+				reader.releaseLock();
+				controller.close();
+			}
+		} }),
+		writable: new WritableStream({ async write(message) {
+			const content = JSON.stringify(message) + "\n";
+			const writer = output.getWriter();
+			try {
+				await writer.write(textEncoder.encode(content));
+			} finally {
+				writer.releaseLock();
+			}
+		} })
+	};
+}
 function isGeminiAcpCommand(command, args) {
 	return basenameToken(command) === "gemini" && (args.includes("--acp") || args.includes("--experimental-acp"));
 }
@@ -733,37 +832,32 @@ function isClaudeAcpCommand(command, args) {
 function isCopilotAcpCommand(command, args) {
 	return basenameToken(command) === "copilot" && args.includes("--acp");
 }
-function readWindowsEnvValue(env, key) {
-	const matchedKey = Object.keys(env).find((entry) => entry.toUpperCase() === key);
-	return matchedKey ? env[matchedKey] : void 0;
+function isQoderAcpCommand(command, args) {
+	return basenameToken(command) === "qodercli" && args.includes("--acp");
 }
-function resolveWindowsCommand(command, env = process.env) {
-	const extensions = (readWindowsEnvValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
-	const candidates = path.extname(command).length > 0 ? [command] : extensions.map((extension) => `${command}${extension}`);
-	if (command.includes("/") || command.includes("\\") || path.isAbsolute(command)) return candidates.find((candidate) => fs.existsSync(candidate));
-	const pathValue = readWindowsEnvValue(env, "PATH");
-	if (!pathValue) return;
-	for (const directory of pathValue.split(";")) {
-		const trimmedDirectory = directory.trim();
-		if (trimmedDirectory.length === 0) continue;
-		for (const candidate of candidates) {
-			const resolved = path.join(trimmedDirectory, candidate);
-			if (fs.existsSync(resolved)) return resolved;
-		}
-	}
+function hasCommandFlag(args, flagName) {
+	return args.some((arg) => arg === flagName || arg.startsWith(`${flagName}=`));
 }
-function shouldUseWindowsBatchShell(command, platform = process.platform, env = process.env) {
-	if (platform !== "win32") return false;
-	const resolvedCommand = resolveWindowsCommand(command, env) ?? command;
-	const ext = path.extname(resolvedCommand).toLowerCase();
-	return ext === ".cmd" || ext === ".bat";
+function normalizeQoderAllowedToolName(tool) {
+	switch (tool.trim().toLowerCase()) {
+		case "bash":
+		case "glob":
+		case "grep":
+		case "ls":
+		case "read":
+		case "write": return tool.trim().toUpperCase();
+		default: return tool.trim();
+	}
 }
-function buildSpawnCommandOptions(command, options, platform = process.platform, env = process.env) {
-	if (!shouldUseWindowsBatchShell(command, platform, env)) return options;
-	return {
-		...options,
-		shell: true
-	};
+function buildQoderAcpCommandArgs(initialArgs, options) {
+	const args = [...initialArgs];
+	const sessionOptions = options.sessionOptions;
+	if (typeof sessionOptions?.maxTurns === "number" && !hasCommandFlag(args, "--max-turns")) args.push(`--max-turns=${sessionOptions.maxTurns}`);
+	if (Array.isArray(sessionOptions?.allowedTools) && !hasCommandFlag(args, "--allowed-tools") && !hasCommandFlag(args, "--disallowed-tools")) {
+		const encodedTools = sessionOptions.allowedTools.map(normalizeQoderAllowedToolName).join(",");
+		args.push(`--allowed-tools=${encodedTools}`);
+	}
+	return args;
 }
 function resolveGeminiAcpStartupTimeoutMs() {
 	const raw = process.env.ACPX_GEMINI_ACP_STARTUP_TIMEOUT_MS;
@@ -904,7 +998,7 @@ async function buildGeminiAcpStartupTimeoutMessage(command) {
 function buildClaudeAcpSessionCreateTimeoutMessage() {
 	return [
 		"Claude ACP session creation timed out before session/new completed.",
-		"This matches the known persistent-session stall seen with some Claude Code and @zed-industries/claude-agent-acp combinations.",
+		"This matches the known persistent-session stall seen with some Claude Code and @agentclientprotocol/claude-agent-acp combinations.",
 		"In harnessed or non-interactive runs, prefer --approve-all with nonInteractivePermissions=deny, upgrade Claude Code and the Claude ACP adapter, or use acpx claude exec as a one-shot fallback."
 	].join(" ");
 }
@@ -922,7 +1016,7 @@ async function ensureCopilotAcpSupport(command) {
 function toEnvToken(value) {
 	return value.trim().replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
 }
-function authEnvKeys(methodId) {
+function buildAuthEnvKeys(methodId) {
 	const token = toEnvToken(methodId);
 	const keys = new Set([methodId]);
 	if (token) {
@@ -931,6 +1025,14 @@ function authEnvKeys(methodId) {
 	}
 	return [...keys];
 }
+const authEnvKeysCache = /* @__PURE__ */ new Map();
+function authEnvKeys(methodId) {
+	const cached = authEnvKeysCache.get(methodId);
+	if (cached) return cached;
+	const keys = buildAuthEnvKeys(methodId);
+	authEnvKeysCache.set(methodId, keys);
+	return keys;
+}
 function readEnvCredential(methodId) {
 	for (const key of authEnvKeys(methodId)) {
 		const value = process.env[key];
@@ -1024,6 +1126,7 @@ var AcpClient = class {
 	lastAgentExit;
 	lastKnownPid;
 	promptPermissionFailures = /* @__PURE__ */ new Map();
+	pendingConnectionRequests = /* @__PURE__ */ new Set();
 	constructor(options) {
 		this.options = {
 			...options,
@@ -1103,7 +1206,8 @@ var AcpClient = class {
 		if (this.connection && this.agent && isChildProcessRunning(this.agent)) return;
 		if (this.connection || this.agent) await this.close();
 		const { command, args: initialArgs } = splitCommandLine(this.options.agentCommand);
-		const args = await resolveGeminiCommandArgs(command, initialArgs);
+		let args = await resolveGeminiCommandArgs(command, initialArgs);
+		if (isQoderAcpCommand(command, args)) args = buildQoderAcpCommandArgs(args, this.options);
 		this.log(`spawning agent: ${command} ${args.join(" ")}`);
 		const geminiAcp = isGeminiAcpCommand(command, args);
 		if (isCopilotAcpCommand(command, args)) await ensureCopilotAcpSupport(command);
@@ -1153,7 +1257,7 @@ var AcpClient = class {
 			releaseTerminal: async (params) => {
 				return this.handleReleaseTerminal(params);
 			}
-		}), this.createTappedStream(ndJsonStream(input, output)));
+		}), this.createTappedStream(createNdJsonMessageStream(this.options.agentCommand, input, output)));
 		connection.signal.addEventListener("abort", () => {
 			this.recordAgentExit("connection_close", child.exitCode ?? null, child.signalCode ?? null);
 		}, { once: true });
@@ -1230,11 +1334,11 @@ var AcpClient = class {
 		const claudeAcp = isClaudeAcpCommand(command, args);
 		let result;
 		try {
-			const createPromise = connection.newSession({
+			const createPromise = this.runConnectionRequest(() => connection.newSession({
 				cwd: asAbsoluteCwd(cwd),
 				mcpServers: this.options.mcpServers ?? [],
 				_meta: buildClaudeCodeOptionsMeta(this.options.sessionOptions)
-			});
+			}));
 			result = claudeAcp ? await withTimeout(createPromise, resolveClaudeAcpSessionCreateTimeoutMs()) : await createPromise;
 		} catch (error) {
 			if (claudeAcp && error instanceof TimeoutError) throw new ClaudeAcpSessionCreateTimeoutError(buildClaudeAcpSessionCreateTimeoutMessage(), {
@@ -1246,7 +1350,8 @@ var AcpClient = class {
 		this.loadedSessionId = result.sessionId;
 		return {
 			sessionId: result.sessionId,
-			agentSessionId: extractRuntimeSessionId(result._meta)
+			agentSessionId: extractRuntimeSessionId(result._meta),
+			models: result.models ?? void 0
 		};
 	}
 	async loadSession(sessionId, cwd = this.options.cwd) {
@@ -1261,28 +1366,31 @@ var AcpClient = class {
 		this.suppressReplaySessionUpdateMessages = previousReplaySuppression || Boolean(options.suppressReplayUpdates);
 		let response;
 		try {
-			response = await connection.loadSession({
+			response = await this.runConnectionRequest(() => connection.loadSession({
 				sessionId,
 				cwd: asAbsoluteCwd(cwd),
 				mcpServers: this.options.mcpServers ?? []
-			});
+			}));
 			await this.waitForSessionUpdateDrain(options.replayIdleMs ?? REPLAY_IDLE_MS, options.replayDrainTimeoutMs ?? REPLAY_DRAIN_TIMEOUT_MS);
 		} finally {
 			this.suppressSessionUpdates = previousSuppression;
 			this.suppressReplaySessionUpdateMessages = previousReplaySuppression;
 		}
 		this.loadedSessionId = sessionId;
-		return { agentSessionId: extractRuntimeSessionId(response?._meta) };
+		return {
+			agentSessionId: extractRuntimeSessionId(response?._meta),
+			models: response?.models ?? void 0
+		};
 	}
 	async prompt(sessionId, prompt) {
 		const connection = this.getConnection();
 		const restoreConsoleError = this.options.suppressSdkConsoleErrors ? installSdkConsoleErrorSuppression() : void 0;
 		let promptPromise;
 		try {
-			promptPromise = connection.prompt({
+			promptPromise = this.runConnectionRequest(() => connection.prompt({
 				sessionId,
 				prompt: typeof prompt === "string" ? textPrompt(prompt) : prompt
-			});
+			}));
 		} catch (error) {
 			restoreConsoleError?.();
 			throw error;
@@ -1310,10 +1418,10 @@ var AcpClient = class {
 	async setSessionMode(sessionId, modeId) {
 		const connection = this.getConnection();
 		try {
-			await connection.setSessionMode({
+			await this.runConnectionRequest(() => connection.setSessionMode({
 				sessionId,
 				modeId
-			});
+			}));
 		} catch (error) {
 			throw maybeWrapSessionControlError("session/set_mode", error, `for mode "${modeId}"`);
 		}
@@ -1321,19 +1429,35 @@ var AcpClient = class {
 	async setSessionConfigOption(sessionId, configId, value) {
 		const connection = this.getConnection();
 		try {
-			return await connection.setSessionConfigOption({
+			return await this.runConnectionRequest(() => connection.setSessionConfigOption({
 				sessionId,
 				configId,
 				value
-			});
+			}));
 		} catch (error) {
 			throw maybeWrapSessionControlError("session/set_config_option", error, `for "${configId}"="${value}"`);
 		}
 	}
+	async setSessionModel(sessionId, modelId) {
+		const connection = this.getConnection();
+		try {
+			await this.runConnectionRequest(() => connection.unstable_setSessionModel({
+				sessionId,
+				modelId
+			}));
+		} catch (error) {
+			const wrapped = maybeWrapSessionControlError("session/set_model", error, `for model "${modelId}"`);
+			if (wrapped !== error) throw wrapped;
+			const acp = extractAcpError(error);
+			const summary = acp ? formatSessionControlAcpSummary(acp) : error instanceof Error ? error.message : String(error);
+			if (error instanceof Error) throw new Error(`Failed session/set_model for model "${modelId}": ${summary}`, { cause: error });
+			throw new Error(`Failed session/set_model for model "${modelId}": ${summary}`, { cause: error });
+		}
+	}
 	async cancel(sessionId) {
 		const connection = this.getConnection();
 		this.cancellingSessionIds.add(sessionId);
-		await connection.cancel({ sessionId });
+		await this.runConnectionRequest(() => connection.cancel({ sessionId }));
 	}
 	async requestCancelActivePrompt() {
 		const active = this.activePrompt;
@@ -1366,6 +1490,7 @@ var AcpClient = class {
 		await this.terminalManager.shutdown();
 		const agent = this.agent;
 		if (agent) await this.terminateAgentProcess(agent);
+		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;
 		this.processedSessionUpdates = 0;
@@ -1380,10 +1505,11 @@ var AcpClient = class {
 		this.agent = void 0;
 	}
 	async terminateAgentProcess(child) {
+		const stdinCloseGraceMs = resolveAgentCloseAfterStdinEndMs(this.options.agentCommand);
 		if (!child.stdin.destroyed) try {
 			child.stdin.end();
 		} catch {}
-		let exited = await waitForChildExit(child, AGENT_CLOSE_AFTER_STDIN_END_MS);
+		let exited = await waitForChildExit(child, stdinCloseGraceMs);
 		if (!exited && isChildProcessRunning(child)) {
 			try {
 				child.kill("SIGTERM");
@@ -1483,6 +1609,7 @@ var AcpClient = class {
 			reason,
 			unexpectedDuringPrompt: !this.closing && Boolean(this.activePrompt)
 		};
+		this.rejectPendingConnectionRequests(new AgentDisconnectedError(reason, exitCode, signal, { outputAlreadyEmitted: Boolean(this.activePrompt) }));
 	}
 	notePromptPermissionFailure(sessionId, error) {
 		if (!this.promptPermissionFailures.has(sessionId)) this.promptPermissionFailures.set(sessionId, error);
@@ -1492,6 +1619,33 @@ var AcpClient = class {
 		if (error) this.promptPermissionFailures.delete(sessionId);
 		return error;
 	}
+	async runConnectionRequest(run) {
+		return await new Promise((resolve, reject) => {
+			const pending = {
+				settled: false,
+				reject
+			};
+			const finish = (cb) => {
+				if (pending.settled) return;
+				pending.settled = true;
+				this.pendingConnectionRequests.delete(pending);
+				cb();
+			};
+			this.pendingConnectionRequests.add(pending);
+			Promise.resolve().then(run).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+		});
+	}
+	rejectPendingConnectionRequests(error) {
+		for (const pending of this.pendingConnectionRequests) {
+			if (pending.settled) {
+				this.pendingConnectionRequests.delete(pending);
+				continue;
+			}
+			pending.settled = true;
+			this.pendingConnectionRequests.delete(pending);
+			pending.reject(error);
+		}
+	}
 	async handleReadTextFile(params) {
 		try {
 			return await this.filesystem.readTextFile(params);
@@ -1908,8 +2062,15 @@ function cloneSessionAcpxState(state) {
 	return {
 		current_mode_id: state.current_mode_id,
 		desired_mode_id: state.desired_mode_id,
+		current_model_id: state.current_model_id,
+		available_models: state.available_models ? [...state.available_models] : void 0,
 		available_commands: state.available_commands ? [...state.available_commands] : void 0,
-		config_options: state.config_options ? deepClone(state.config_options) : void 0
+		config_options: state.config_options ? deepClone(state.config_options) : void 0,
+		session_options: state.session_options ? {
+			model: state.session_options.model,
+			allowed_tools: state.session_options.allowed_tools ? [...state.session_options.allowed_tools] : void 0,
+			max_turns: state.session_options.max_turns
+		} : void 0
 	};
 }
 function recordPromptSubmission(conversation, prompt, timestamp = isoNow$1()) {
@@ -2264,8 +2425,18 @@ function parseAcpxState(raw) {
 	const state = {};
 	if (typeof record.current_mode_id === "string") state.current_mode_id = record.current_mode_id;
 	if (typeof record.desired_mode_id === "string") state.desired_mode_id = record.desired_mode_id;
+	if (typeof record.current_model_id === "string") state.current_model_id = record.current_model_id;
+	if (isStringArray(record.available_models)) state.available_models = [...record.available_models];
 	if (isStringArray(record.available_commands)) state.available_commands = [...record.available_commands];
 	if (Array.isArray(record.config_options)) state.config_options = record.config_options;
+	const sessionOptions = asRecord$1(record.session_options);
+	if (sessionOptions) {
+		const parsedSessionOptions = {};
+		if (typeof sessionOptions.model === "string") parsedSessionOptions.model = sessionOptions.model;
+		if (isStringArray(sessionOptions.allowed_tools)) parsedSessionOptions.allowed_tools = [...sessionOptions.allowed_tools];
+		if (typeof sessionOptions.max_turns === "number" && Number.isInteger(sessionOptions.max_turns) && sessionOptions.max_turns > 0) parsedSessionOptions.max_turns = sessionOptions.max_turns;
+		if (Object.keys(parsedSessionOptions).length > 0) state.session_options = parsedSessionOptions;
+	}
 	return state;
 }
 function parseEventLog(raw, sessionId) {
@@ -2865,6 +3036,15 @@ var QueueOwnerTurnController = class {
 		}
 		await this.options.setSessionModeFallback(modeId, timeoutMs);
 	}
+	async setSessionModel(modelId, timeoutMs) {
+		this.assertCanHandleControlRequest();
+		const activeController = this.activeController;
+		if (activeController) {
+			await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
+			return;
+		}
+		await this.options.setSessionModelFallback(modelId, timeoutMs);
+	}
 	async setSessionConfigOption(configId, value, timeoutMs) {
 		this.assertCanHandleControlRequest();
 		const activeController = this.activeController;
@@ -2882,6 +3062,11 @@ function normalizeModeId(modeId) {
 	const trimmed = modeId.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
 }
+function normalizeModelId(modelId) {
+	if (typeof modelId !== "string") return;
+	const trimmed = modelId.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
 function getDesiredModeId(state) {
 	return normalizeModeId(state?.desired_mode_id);
 }
@@ -2892,6 +3077,33 @@ function setDesiredModeId(record, modeId) {
 	else delete acpx.desired_mode_id;
 	record.acpx = acpx;
 }
+function getDesiredModelId(state) {
+	return normalizeModelId(state?.session_options?.model);
+}
+function setDesiredModelId(record, modelId) {
+	const acpx = ensureAcpxState(record.acpx);
+	const normalized = normalizeModelId(modelId);
+	const sessionOptions = { ...acpx.session_options };
+	if (normalized) sessionOptions.model = normalized;
+	else delete sessionOptions.model;
+	if (typeof sessionOptions.model === "string" || Array.isArray(sessionOptions.allowed_tools) || typeof sessionOptions.max_turns === "number") acpx.session_options = sessionOptions;
+	else delete acpx.session_options;
+	record.acpx = acpx;
+}
+function setCurrentModelId(record, modelId) {
+	const acpx = ensureAcpxState(record.acpx);
+	const normalized = normalizeModelId(modelId);
+	if (normalized) acpx.current_model_id = normalized;
+	else delete acpx.current_model_id;
+	record.acpx = acpx;
+}
+function syncAdvertisedModelState(record, models) {
+	if (!models) return;
+	const acpx = ensureAcpxState(record.acpx);
+	acpx.current_model_id = models.currentModelId;
+	acpx.available_models = models.availableModels.map((model) => model.modelId);
+	record.acpx = acpx;
+}
 //#endregion
 //#region src/session-runtime/lifecycle.ts
 function applyLifecycleSnapshotToRecord(record, snapshot) {
@@ -2926,21 +3138,32 @@ function applyConversation(record, conversation) {
 }
 //#endregion
 //#region src/session-runtime/connect-load.ts
+const SESSION_LOAD_UNSUPPORTED_CODES = new Set([-32601, -32602]);
 function shouldFallbackToNewSession(error, record) {
 	if (error instanceof TimeoutError || error instanceof InterruptedError) return false;
 	if (isAcpResourceNotFoundError(error)) return true;
+	const acp = extractAcpError(error);
+	if (acp && SESSION_LOAD_UNSUPPORTED_CODES.has(acp.code)) return true;
 	if (!sessionHasAgentMessages(record)) {
 		if (isAcpQueryClosedBeforeResponseError(error)) return true;
-		if (extractAcpError(error)?.code === -32603) return true;
+		if (acp?.code === -32603) return true;
 	}
 	return false;
 }
+function requiresSameSession(resumePolicy) {
+	return resumePolicy === "same-session-only";
+}
+function makeSessionResumeRequiredError(params) {
+	return new SessionResumeRequiredError(`Persistent ACP session ${params.record.acpSessionId} could not be resumed: ${params.reason}`, { cause: params.cause instanceof Error ? params.cause : void 0 });
+}
 async function connectAndLoadSession(options) {
 	const record = options.record;
 	const client = options.client;
+	const sameSessionOnly = requiresSameSession(options.resumePolicy);
 	const originalSessionId = record.acpSessionId;
 	const originalAgentSessionId = record.agentSessionId;
 	const desiredModeId = getDesiredModeId(record.acpx);
+	const desiredModelId = getDesiredModelId(record.acpx);
 	const storedProcessAlive = isProcessAlive(record.pid);
 	const shouldReconnect = Boolean(record.pid) && !storedProcessAlive;
 	if (options.verbose) {
@@ -2960,23 +3183,37 @@ async function connectAndLoadSession(options) {
 	let sessionId = record.acpSessionId;
 	let createdFreshSession = false;
 	let pendingAgentSessionId = record.agentSessionId;
+	let sessionModels;
 	if (reusingLoadedSession) resumed = true;
 	else if (client.supportsLoadSession()) try {
-		reconcileAgentSessionId(record, (await withTimeout(client.loadSessionWithOptions(record.acpSessionId, record.cwd, { suppressReplayUpdates: true }), options.timeoutMs)).agentSessionId);
+		const loadResult = await withTimeout(client.loadSessionWithOptions(record.acpSessionId, record.cwd, { suppressReplayUpdates: true }), options.timeoutMs);
+		reconcileAgentSessionId(record, loadResult.agentSessionId);
+		sessionModels = loadResult.models;
 		resumed = true;
 	} catch (error) {
 		loadError = formatErrorMessage(error);
+		if (sameSessionOnly) throw makeSessionResumeRequiredError({
+			record,
+			reason: loadError,
+			cause: error
+		});
 		if (!shouldFallbackToNewSession(error, record)) throw error;
 		const createdSession = await withTimeout(client.createSession(record.cwd), options.timeoutMs);
 		sessionId = createdSession.sessionId;
 		createdFreshSession = true;
 		pendingAgentSessionId = createdSession.agentSessionId;
+		sessionModels = createdSession.models;
 	}
 	else {
+		if (sameSessionOnly) throw makeSessionResumeRequiredError({
+			record,
+			reason: "agent does not support session/load"
+		});
 		const createdSession = await withTimeout(client.createSession(record.cwd), options.timeoutMs);
 		sessionId = createdSession.sessionId;
 		createdFreshSession = true;
 		pendingAgentSessionId = createdSession.agentSessionId;
+		sessionModels = createdSession.models;
 	}
 	if (createdFreshSession && desiredModeId) try {
 		await withTimeout(client.setSessionMode(sessionId, desiredModeId), options.timeoutMs);
@@ -2991,10 +3228,26 @@ async function connectAndLoadSession(options) {
 			retryable: true
 		});
 	}
+	if (createdFreshSession && desiredModelId && sessionModels && desiredModelId !== sessionModels.currentModelId) try {
+		await withTimeout(client.setSessionModel(sessionId, desiredModelId), options.timeoutMs);
+		setCurrentModelId(record, desiredModelId);
+		if (options.verbose) process.stderr.write(`[acpx] replayed desired model ${desiredModelId} on fresh ACP session ${sessionId} (previous ${originalSessionId})\n`);
+	} catch (error) {
+		const message = `Failed to replay saved session model ${desiredModelId} on fresh ACP session ${sessionId}: ` + formatErrorMessage(error);
+		record.acpSessionId = originalSessionId;
+		record.agentSessionId = originalAgentSessionId;
+		if (options.verbose) process.stderr.write(`[acpx] ${message}\n`);
+		throw new SessionModelReplayError(message, {
+			cause: error instanceof Error ? error : void 0,
+			retryable: true
+		});
+	}
 	if (createdFreshSession) {
 		record.acpSessionId = sessionId;
 		reconcileAgentSessionId(record, pendingAgentSessionId);
 	}
+	syncAdvertisedModelState(record, sessionModels);
+	if (createdFreshSession && desiredModelId && sessionModels) setCurrentModelId(record, desiredModelId);
 	options.onSessionIdResolved?.(sessionId);
 	return {
 		sessionId,
@@ -3005,6 +3258,15 @@ async function connectAndLoadSession(options) {
 }
 //#endregion
 //#region src/session-runtime/prompt-runner.ts
+function sessionOptionsFromRecord$1(record) {
+	const stored = record.acpx?.session_options;
+	if (!stored) return;
+	const sessionOptions = {};
+	if (typeof stored.model === "string" && stored.model.trim().length > 0) sessionOptions.model = stored.model;
+	if (Array.isArray(stored.allowed_tools)) sessionOptions.allowedTools = [...stored.allowed_tools];
+	if (typeof stored.max_turns === "number") sessionOptions.maxTurns = stored.max_turns;
+	return Object.keys(sessionOptions).length > 0 ? sessionOptions : void 0;
+}
 async function withConnectedSession(options) {
 	const record = await resolveSessionRecord(options.sessionRecordId);
 	const client = new AcpClient({
@@ -3015,7 +3277,8 @@ async function withConnectedSession(options) {
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
-		verbose: options.verbose
+		verbose: options.verbose,
+		sessionOptions: sessionOptionsFromRecord$1(record)
 	});
 	let activeSessionIdForControl = record.acpSessionId;
 	let notifiedClientAvailable = false;
@@ -3025,6 +3288,9 @@ async function withConnectedSession(options) {
 		setSessionMode: async (modeId) => {
 			await client.setSessionMode(activeSessionIdForControl, modeId);
 		},
+		setSessionModel: async (modelId) => {
+			await client.setSessionModel(activeSessionIdForControl, modelId);
+		},
 		setSessionConfigOption: async (configId, value) => {
 			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
 		}
@@ -3095,6 +3361,29 @@ async function runSessionSetModeDirect(options) {
 		loadError: result.loadError
 	};
 }
+async function runSessionSetModelDirect(options) {
+	const result = await withConnectedSession({
+		sessionRecordId: options.sessionRecordId,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose,
+		onClientAvailable: options.onClientAvailable,
+		onClientClosed: options.onClientClosed,
+		run: async (client, sessionId, record) => {
+			await withTimeout(client.setSessionModel(sessionId, options.modelId), options.timeoutMs);
+			setDesiredModelId(record, options.modelId);
+			setCurrentModelId(record, options.modelId);
+		}
+	});
+	return {
+		record: result.record,
+		resumed: result.resumed,
+		loadError: result.loadError
+	};
+}
 async function runSessionSetConfigOptionDirect(options) {
 	const result = await withConnectedSession({
 		sessionRecordId: options.sessionRecordId,
@@ -3121,7 +3410,40 @@ async function runSessionSetConfigOptionDirect(options) {
 }
 //#endregion
 //#region src/session-runtime/queue-owner-process.ts
+function sanitizeQueueOwnerExecArgv(execArgv = process.execArgv) {
+	const sanitized = [];
+	for (let index = 0; index < execArgv.length; index += 1) {
+		const value = execArgv[index];
+		if (value === "--experimental-test-coverage" || value === "--test") continue;
+		if (value === "--test-name-pattern" || value === "--test-reporter" || value === "--test-reporter-destination") {
+			index += 1;
+			continue;
+		}
+		if (value.startsWith("--test-")) continue;
+		if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value.startsWith("--inspect=") || value.startsWith("--inspect-brk=") || value.startsWith("--inspect-port=") || value.startsWith("--inspect-publish-uid=") || value === "--debug-port" || value.startsWith("--debug-port=")) {
+			if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value === "--debug-port") index += 1;
+			continue;
+		}
+		sanitized.push(value);
+	}
+	return sanitized;
+}
+function buildQueueOwnerArgOverride(entryPath, execArgv = process.execArgv) {
+	const sanitized = sanitizeQueueOwnerExecArgv(execArgv);
+	if (sanitized.length === 0) return null;
+	return JSON.stringify([
+		...sanitized,
+		entryPath,
+		"__queue-owner"
+	]);
+}
 function resolveQueueOwnerSpawnArgs(argv = process.argv) {
+	const override = process.env.ACPX_QUEUE_OWNER_ARGS;
+	if (override) {
+		const parsed = JSON.parse(override);
+		if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string" && value.length > 0)) return [...parsed];
+		throw new Error("acpx self-spawn failed: invalid ACPX_QUEUE_OWNER_ARGS");
+	}
 	const entry = argv[1];
 	if (!entry || entry.trim().length === 0) throw new Error("acpx self-spawn failed: missing CLI entry path");
 	return [realpathSync(entry), "__queue-owner"];
@@ -3137,7 +3459,8 @@ function queueOwnerRuntimeOptionsFromSend(options) {
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
 		verbose: options.verbose,
 		ttlMs: options.ttlMs,
-		maxQueueDepth: options.maxQueueDepth
+		maxQueueDepth: options.maxQueueDepth,
+		promptRetries: options.promptRetries
 	};
 }
 function buildQueueOwnerSpawnOptions(payload) {
@@ -3161,6 +3484,31 @@ const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
 const INTERRUPT_CANCEL_WAIT_MS = 2500;
 const QUEUE_OWNER_STARTUP_MAX_ATTEMPTS = 120;
 const QUEUE_OWNER_HEARTBEAT_INTERVAL_MS = 5e3;
+function sessionOptionsFromRecord(record) {
+	const stored = record.acpx?.session_options;
+	if (!stored) return;
+	const sessionOptions = {};
+	if (typeof stored.model === "string" && stored.model.trim().length > 0) sessionOptions.model = stored.model;
+	if (Array.isArray(stored.allowed_tools)) sessionOptions.allowedTools = [...stored.allowed_tools];
+	if (typeof stored.max_turns === "number") sessionOptions.maxTurns = stored.max_turns;
+	return Object.keys(sessionOptions).length > 0 ? sessionOptions : void 0;
+}
+function persistSessionOptions(record, options) {
+	const next = options && {
+		model: typeof options.model === "string" ? options.model : void 0,
+		allowed_tools: Array.isArray(options.allowedTools) ? [...options.allowedTools] : void 0,
+		max_turns: typeof options.maxTurns === "number" ? options.maxTurns : void 0
+	};
+	if (Boolean(next && (typeof next.model === "string" && next.model.trim().length > 0 || Array.isArray(next.allowed_tools) && next.allowed_tools.length > 0 || typeof next.max_turns === "number")) && next) {
+		record.acpx = {
+			...record.acpx,
+			session_options: next
+		};
+		return;
+	}
+	if (!record.acpx) return;
+	delete record.acpx.session_options;
+}
 function toPromptResult(stopReason, sessionId, client) {
 	return {
 		stopReason,
@@ -3168,6 +3516,13 @@ function toPromptResult(stopReason, sessionId, client) {
 		permissionStats: client.getPermissionStats()
 	};
 }
+async function applyRequestedModelIfAdvertised(params) {
+	const requestedModel = typeof params.requestedModel === "string" ? params.requestedModel.trim() : "";
+	if (!requestedModel || !params.models) return false;
+	if (params.models.currentModelId === requestedModel) return true;
+	await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel), params.timeoutMs);
+	return true;
+}
 var QueueTaskOutputFormatter = class {
 	requestId;
 	send;
@@ -3255,6 +3610,10 @@ function normalizeQueueOwnerTtlMs(ttlMs) {
 	if (!Number.isFinite(ttlMs) || ttlMs < 0) return DEFAULT_QUEUE_OWNER_TTL_MS;
 	return Math.round(ttlMs);
 }
+function emitPromptRetryNotice(params) {
+	if (params.suppressSdkConsoleErrors) return;
+	process.stderr.write(`[acpx] prompt failed (${formatErrorMessage(params.error)}), retrying in ${params.delayMs}ms (attempt ${params.attempt}/${params.maxRetries})\n`);
+}
 async function runQueuedTask(sessionRecordId, task, options) {
 	const outputFormatter = task.waitForCompletion ? new QueueTaskOutputFormatter(task) : DISCARD_OUTPUT_FORMATTER;
 	try {
@@ -3263,6 +3622,7 @@ async function runQueuedTask(sessionRecordId, task, options) {
 			mcpServers: options.mcpServers,
 			prompt: task.prompt ?? textPrompt(task.message),
 			permissionMode: task.permissionMode,
+			resumePolicy: task.resumePolicy,
 			nonInteractivePermissions: task.nonInteractivePermissions ?? options.nonInteractivePermissions,
 			authCredentials: options.authCredentials,
 			authPolicy: options.authPolicy,
@@ -3270,6 +3630,7 @@ async function runQueuedTask(sessionRecordId, task, options) {
 			timeoutMs: task.timeoutMs,
 			suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
 			verbose: options.verbose,
+			promptRetries: options.promptRetries,
 			onClientAvailable: options.onClientAvailable,
 			onClientClosed: options.onClientClosed,
 			onPromptActive: options.onPromptActive,
@@ -3318,6 +3679,8 @@ async function runSessionPrompt(options) {
 	const pendingMessages = [];
 	const pendingConnectOutputMessages = [];
 	let bufferingConnectOutput = true;
+	let promptTurnActive = false;
+	let promptTurnHadSideEffects = false;
 	let sawAcpMessage = false;
 	let eventWriterClosed = false;
 	const closeEventWriter = async (checkpoint) => {
@@ -3342,7 +3705,8 @@ async function runSessionPrompt(options) {
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-		verbose: options.verbose
+		verbose: options.verbose,
+		sessionOptions: sessionOptionsFromRecord(record)
 	});
 	client.updateRuntimeOptions({
 		permissionMode: options.permissionMode,
@@ -3351,9 +3715,10 @@ async function runSessionPrompt(options) {
 		verbose: options.verbose
 	});
 	client.setEventHandlers({
-		onAcpMessage: (_direction, message) => {
+		onAcpMessage: (direction, message) => {
 			sawAcpMessage = true;
 			pendingMessages.push(message);
+			options.onAcpMessage?.(direction, message);
 		},
 		onAcpOutputMessage: (_direction, message) => {
 			if (bufferingConnectOutput) {
@@ -3363,12 +3728,16 @@ async function runSessionPrompt(options) {
 			output.onAcpMessage(message);
 		},
 		onSessionUpdate: (notification) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
 			acpxState = recordSessionUpdate(conversation, acpxState, notification);
 			trimConversationForRuntime(conversation);
+			options.onSessionUpdate?.(notification);
 		},
 		onClientOperation: (operation) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
 			acpxState = recordClientOperation(conversation, acpxState, operation);
 			trimConversationForRuntime(conversation);
+			options.onClientOperation?.(operation);
 		}
 	});
 	let activeSessionIdForControl = record.acpSessionId;
@@ -3379,6 +3748,9 @@ async function runSessionPrompt(options) {
 		setSessionMode: async (modeId) => {
 			await client.setSessionMode(activeSessionIdForControl, modeId);
 		},
+		setSessionModel: async (modelId) => {
+			await client.setSessionModel(activeSessionIdForControl, modelId);
+		},
 		setSessionConfigOption: async (configId, value) => {
 			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
 		}
@@ -3391,6 +3763,7 @@ async function runSessionPrompt(options) {
 					return await connectAndLoadSession({
 						client,
 						record,
+						resumePolicy: options.resumePolicy,
 						timeoutMs: options.timeoutMs,
 						verbose: options.verbose,
 						activeController,
@@ -3419,11 +3792,13 @@ async function runSessionPrompt(options) {
 			if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.connect_and_load", Date.now() - connectStartedAt)}\n`);
 			output.setContext({ sessionId: record.acpxRecordId });
 			await flushPendingMessages(false);
+			const maxRetries = options.promptRetries ?? 0;
 			let response;
-			try {
+			promptTurnActive = true;
+			for (let attempt = 0;; attempt++) try {
 				const promptStartedAt = Date.now();
 				const promptPromise = client.prompt(activeSessionId, options.prompt);
-				if (options.onPromptActive) try {
+				if (attempt === 0 && options.onPromptActive) try {
 					await options.onPromptActive();
 				} catch (error) {
 					if (options.verbose) process.stderr.write("[acpx] onPromptActive hook failed: " + formatErrorMessage(error) + "\n");
@@ -3432,10 +3807,26 @@ async function runSessionPrompt(options) {
 					return await withTimeout(promptPromise, options.timeoutMs);
 				});
 				if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.agent_turn", Date.now() - promptStartedAt)}\n`);
+				break;
 			} catch (error) {
 				const snapshot = client.getAgentLifecycleSnapshot();
+				const agentCrashed = snapshot.lastExit?.unexpectedDuringPrompt === true;
+				if (attempt < maxRetries && !agentCrashed && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
+					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+					emitPromptRetryNotice({
+						error,
+						delayMs,
+						attempt: attempt + 1,
+						maxRetries,
+						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
+					});
+					await waitMs$1(delayMs);
+					if (!promptTurnHadSideEffects) continue;
+				}
+				promptTurnActive = false;
 				applyLifecycleSnapshotToRecord(record, snapshot);
-				if (snapshot.lastExit?.unexpectedDuringPrompt && options.verbose) process.stderr.write("[acpx] agent disconnected during prompt (" + snapshot.lastExit.reason + ", exit=" + snapshot.lastExit.exitCode + ", signal=" + (snapshot.lastExit.signal ?? "none") + ")\n");
+				const lastExit = snapshot.lastExit;
+				if (lastExit?.unexpectedDuringPrompt && options.verbose) process.stderr.write("[acpx] agent disconnected during prompt (" + lastExit.reason + ", exit=" + lastExit.exitCode + ", signal=" + (lastExit.signal ?? "none") + ")\n");
 				const normalizedError = normalizeOutputError(error, { origin: "runtime" });
 				await flushPendingMessages(false).catch(() => {});
 				output.flush();
@@ -3447,6 +3838,7 @@ async function runSessionPrompt(options) {
 				propagated.normalizedOutputError = normalizedError;
 				throw propagated;
 			}
+			promptTurnActive = false;
 			await flushPendingMessages(false);
 			output.flush();
 			record.lastUsedAt = isoNow();
@@ -3488,6 +3880,8 @@ async function runSessionPrompt(options) {
 }
 async function runOnce(options) {
 	const output = options.outputFormatter;
+	let promptTurnActive = false;
+	let promptTurnHadSideEffects = false;
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		cwd: absolutePath(options.cwd),
@@ -3498,7 +3892,16 @@ async function runOnce(options) {
 		authPolicy: options.authPolicy,
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
 		verbose: options.verbose,
+		onAcpMessage: options.onAcpMessage,
 		onAcpOutputMessage: (_direction, message) => output.onAcpMessage(message),
+		onSessionUpdate: (notification) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			options.onSessionUpdate?.(notification);
+		},
+		onClientOperation: (operation) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			options.onClientOperation?.(operation);
+		},
 		sessionOptions: options.sessionOptions
 	});
 	try {
@@ -3506,13 +3909,43 @@ async function runOnce(options) {
 			await measurePerf("runtime.exec.start", async () => {
 				await withTimeout(client.start(), options.timeoutMs);
 			});
-			const sessionId = (await measurePerf("runtime.exec.create_session", async () => {
+			const createdSession = await measurePerf("runtime.exec.create_session", async () => {
 				return await withTimeout(client.createSession(absolutePath(options.cwd)), options.timeoutMs);
-			})).sessionId;
-			output.setContext({ sessionId });
-			const response = await measurePerf("runtime.exec.prompt", async () => {
-				return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
 			});
+			const sessionId = createdSession.sessionId;
+			await applyRequestedModelIfAdvertised({
+				client,
+				sessionId,
+				requestedModel: options.sessionOptions?.model,
+				models: createdSession.models,
+				timeoutMs: options.timeoutMs
+			});
+			output.setContext({ sessionId });
+			const maxRetries = options.promptRetries ?? 0;
+			let response;
+			promptTurnActive = true;
+			for (let attempt = 0;; attempt++) try {
+				response = await measurePerf("runtime.exec.prompt", async () => {
+					return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
+				});
+				break;
+			} catch (error) {
+				if (attempt < maxRetries && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
+					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+					emitPromptRetryNotice({
+						error,
+						delayMs,
+						attempt: attempt + 1,
+						maxRetries,
+						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
+					});
+					await waitMs$1(delayMs);
+					if (!promptTurnHadSideEffects) continue;
+				}
+				promptTurnActive = false;
+				throw error;
+			}
+			promptTurnActive = false;
 			output.flush();
 			return toPromptResult(response.stopReason, sessionId, client);
 		}, async () => {
@@ -3523,7 +3956,78 @@ async function runOnce(options) {
 		await client.close();
 	}
 }
-async function createSession(options) {
+async function createSessionRecordWithClient(client, options) {
+	const cwd = absolutePath(options.cwd);
+	await measurePerf("runtime.session_create.start", async () => {
+		await withTimeout(client.start(), options.timeoutMs);
+	});
+	let sessionId;
+	let agentSessionId;
+	let sessionModels;
+	let requestedModelApplied = false;
+	if (options.resumeSessionId) {
+		if (!client.supportsLoadSession()) throw new Error(`Agent command "${options.agentCommand}" does not support session/load; cannot resume session ${options.resumeSessionId}`);
+		try {
+			const loadedSession = await withTimeout(client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
+			sessionId = options.resumeSessionId;
+			agentSessionId = normalizeRuntimeSessionId(loadedSession.agentSessionId);
+			sessionModels = loadedSession.models;
+			requestedModelApplied = await applyRequestedModelIfAdvertised({
+				client,
+				sessionId,
+				requestedModel: options.sessionOptions?.model,
+				models: loadedSession.models,
+				timeoutMs: options.timeoutMs
+			});
+		} catch (error) {
+			throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
+		}
+	} else {
+		const createdSession = await measurePerf("runtime.session_create.create_session", async () => {
+			return await withTimeout(client.createSession(cwd), options.timeoutMs);
+		});
+		sessionId = createdSession.sessionId;
+		agentSessionId = normalizeRuntimeSessionId(createdSession.agentSessionId);
+		sessionModels = createdSession.models;
+		requestedModelApplied = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId,
+			requestedModel: options.sessionOptions?.model,
+			models: createdSession.models,
+			timeoutMs: options.timeoutMs
+		});
+	}
+	const lifecycle = client.getAgentLifecycleSnapshot();
+	const now = isoNow();
+	const record = {
+		schema: SESSION_RECORD_SCHEMA,
+		acpxRecordId: sessionId,
+		acpSessionId: sessionId,
+		agentSessionId,
+		agentCommand: options.agentCommand,
+		cwd,
+		name: normalizeName(options.name),
+		createdAt: now,
+		lastUsedAt: now,
+		lastSeq: 0,
+		lastRequestId: void 0,
+		eventLog: defaultSessionEventLog(sessionId),
+		closed: false,
+		closedAt: void 0,
+		pid: lifecycle.pid,
+		agentStartedAt: lifecycle.startedAt,
+		protocolVersion: client.initializeResult?.protocolVersion,
+		agentCapabilities: client.initializeResult?.agentCapabilities,
+		...createSessionConversation(now),
+		acpx: {}
+	};
+	persistSessionOptions(record, options.sessionOptions);
+	syncAdvertisedModelState(record, sessionModels);
+	if (requestedModelApplied) setCurrentModelId(record, options.sessionOptions?.model);
+	await writeSessionRecord(record);
+	return record;
+}
+async function createSessionWithClient(options) {
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		cwd: absolutePath(options.cwd),
@@ -3536,56 +4040,23 @@ async function createSession(options) {
 		sessionOptions: options.sessionOptions
 	});
 	try {
-		return await withInterrupt(async () => {
-			const cwd = absolutePath(options.cwd);
-			await measurePerf("runtime.session_create.start", async () => {
-				await withTimeout(client.start(), options.timeoutMs);
-			});
-			let sessionId;
-			let agentSessionId;
-			if (options.resumeSessionId) {
-				if (!client.supportsLoadSession()) throw new Error(`Agent command "${options.agentCommand}" does not support session/load; cannot resume session ${options.resumeSessionId}`);
-				try {
-					const loadedSession = await withTimeout(client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
-					sessionId = options.resumeSessionId;
-					agentSessionId = normalizeRuntimeSessionId(loadedSession.agentSessionId);
-				} catch (error) {
-					throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
-				}
-			} else {
-				const createdSession = await measurePerf("runtime.session_create.create_session", async () => await withTimeout(client.createSession(cwd), options.timeoutMs));
-				sessionId = createdSession.sessionId;
-				agentSessionId = normalizeRuntimeSessionId(createdSession.agentSessionId);
-			}
-			const lifecycle = client.getAgentLifecycleSnapshot();
-			const now = isoNow();
-			const record = {
-				schema: SESSION_RECORD_SCHEMA,
-				acpxRecordId: sessionId,
-				acpSessionId: sessionId,
-				agentSessionId,
-				agentCommand: options.agentCommand,
-				cwd,
-				name: normalizeName(options.name),
-				createdAt: now,
-				lastUsedAt: now,
-				lastSeq: 0,
-				lastRequestId: void 0,
-				eventLog: defaultSessionEventLog(sessionId),
-				closed: false,
-				closedAt: void 0,
-				pid: lifecycle.pid,
-				agentStartedAt: lifecycle.startedAt,
-				protocolVersion: client.initializeResult?.protocolVersion,
-				agentCapabilities: client.initializeResult?.agentCapabilities,
-				...createSessionConversation(now),
-				acpx: {}
-			};
-			await writeSessionRecord(record);
-			return record;
-		}, async () => {
-			await client.close();
-		});
+		return {
+			record: await withInterrupt(async () => {
+				return await createSessionRecordWithClient(client, options);
+			}, async () => {
+				await client.close();
+			}),
+			client
+		};
+	} catch (error) {
+		await client.close();
+		throw error;
+	}
+}
+async function createSession(options) {
+	const { record, client } = await createSessionWithClient(options);
+	try {
+		return record;
 	} finally {
 		await client.close();
 	}
@@ -3600,10 +4071,26 @@ async function ensureSession(options) {
 		name: options.name,
 		boundary: walkBoundary
 	});
-	if (existing) return {
-		record: existing,
-		created: false
-	};
+	if (existing) {
+		const requestedModel = options.sessionOptions?.model;
+		if (requestedModel) return {
+			record: (await setSessionModel({
+				sessionId: existing.acpxRecordId,
+				modelId: requestedModel,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				timeoutMs: options.timeoutMs,
+				verbose: options.verbose
+			})).record,
+			created: false
+		};
+		return {
+			record: existing,
+			created: false
+		};
+	}
 	return {
 		record: await createSession({
 			agentCommand: options.agentCommand,
@@ -3647,12 +4134,13 @@ async function runSessionQueueOwner(options) {
 		agentCommand: sessionRecord.agentCommand,
 		cwd: absolutePath(sessionRecord.cwd),
 		mcpServers: options.mcpServers,
-		permissionMode: "approve-reads",
+		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-		verbose: options.verbose
+		verbose: options.verbose,
+		sessionOptions: sessionOptionsFromRecord(sessionRecord)
 	});
 	const ttlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
 	const maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth ?? 16));
@@ -3672,6 +4160,18 @@ async function runSessionQueueOwner(options) {
 				verbose: options.verbose
 			});
 		},
+		setSessionModelFallback: async (modelId, timeoutMs) => {
+			await runSessionSetModelDirect({
+				sessionRecordId: options.sessionId,
+				modelId,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				timeoutMs,
+				verbose: options.verbose
+			});
+		},
 		setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
 			return (await runSessionSetConfigOptionDirect({
 				sessionRecordId: options.sessionId,
@@ -3719,6 +4219,9 @@ async function runSessionQueueOwner(options) {
 			setSessionMode: async (modeId, timeoutMs) => {
 				await turnController.setSessionMode(modeId, timeoutMs);
 			},
+			setSessionModel: async (modelId, timeoutMs) => {
+				await turnController.setSessionModel(modelId, timeoutMs);
+			},
 			setSessionConfigOption: async (configId, value, timeoutMs) => {
 				return await turnController.setSessionConfigOption(configId, value, timeoutMs);
 			}
@@ -3750,6 +4253,7 @@ async function runSessionQueueOwner(options) {
 						authCredentials: options.authCredentials,
 						authPolicy: options.authPolicy,
 						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+						promptRetries: options.promptRetries,
 						onClientAvailable: setActiveController,
 						onClientClosed: clearActiveController,
 						onPromptActive: async () => {
@@ -3788,6 +4292,26 @@ async function sendSession(options) {
 	}
 	throw new Error(`Session queue owner failed to start for session ${options.sessionId}`);
 }
+async function sendSessionDirect(options) {
+	return await runSessionPrompt({
+		sessionRecordId: options.sessionId,
+		prompt: options.prompt,
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		resumePolicy: options.resumePolicy,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		outputFormatter: options.outputFormatter,
+		onAcpMessage: options.onAcpMessage,
+		onSessionUpdate: options.onSessionUpdate,
+		onClientOperation: options.onClientOperation,
+		timeoutMs: options.timeoutMs,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		client: options.client
+	});
+}
 async function cancelSessionPrompt(options) {
 	const cancelled = await tryCancelOnRunningOwner(options);
 	return {
@@ -3816,6 +4340,28 @@ async function setSessionMode(options) {
 		verbose: options.verbose
 	});
 }
+async function setSessionModel(options) {
+	if (await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose)) {
+		const record = await resolveSessionRecord(options.sessionId);
+		setDesiredModelId(record, options.modelId);
+		setCurrentModelId(record, options.modelId);
+		await writeSessionRecord(record);
+		return {
+			record,
+			resumed: false
+		};
+	}
+	return await runSessionSetModelDirect({
+		sessionRecordId: options.sessionId,
+		modelId: options.modelId,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose
+	});
+}
 async function setSessionConfigOption(options) {
 	const ownerResponse = await trySetConfigOptionOnRunningOwner(options.sessionId, options.configId, options.value, options.timeoutMs, options.verbose);
 	if (ownerResponse) {
@@ -3882,6 +4428,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	cancelSessionPrompt: () => cancelSessionPrompt,
 	closeSession: () => closeSession,
 	createSession: () => createSession,
+	createSessionWithClient: () => createSessionWithClient,
 	ensureSession: () => ensureSession,
 	findGitRepositoryRoot: () => findGitRepositoryRoot,
 	findSession: () => findSession,
@@ -3893,10 +4440,12 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	runOnce: () => runOnce,
 	runSessionQueueOwner: () => runSessionQueueOwner,
 	sendSession: () => sendSession,
+	sendSessionDirect: () => sendSessionDirect,
 	setSessionConfigOption: () => setSessionConfigOption,
-	setSessionMode: () => setSessionMode
+	setSessionMode: () => setSessionMode,
+	setSessionModel: () => setSessionModel
 });
 //#endregion
-export { findGitRepositoryRoot as a, flushPerfMetricsCapture as c, DEFAULT_HISTORY_LIMIT as i, installPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as n, findSession as o, runSessionQueueOwner as r, findSessionByDirectoryWalk as s, session_exports as t, InterruptedError as u };
+export { TimeoutError as C, permissionModeSatisfies as E, InterruptedError as S, withTimeout as T, recordClientOperation as _, runOnce as a, flushPerfMetricsCapture as b, buildQueueOwnerArgOverride as c, findSession as d, findSessionByDirectoryWalk as f, createSessionConversation as g, cloneSessionAcpxState as h, createSessionWithClient as i, DEFAULT_HISTORY_LIMIT as l, defaultSessionEventLog as m, DEFAULT_QUEUE_OWNER_TTL_MS as n, runSessionQueueOwner as o, resolveSessionRecord as p, cancelSessionPrompt as r, sendSessionDirect as s, session_exports as t, findGitRepositoryRoot as u, recordPromptSubmission as v, withInterrupt as w, installPerfMetricsCapture as x, recordSessionUpdate as y };
 
-//# sourceMappingURL=session-C2Q8ktsN.js.map
+//# sourceMappingURL=session-RO_LZUnv.js.map