acpx 0.5.3 → 0.6.1

package/dist/runtime.js

@@ -1,5 +1,5 @@
-import { C as isAcpResourceNotFoundError, S as extractAcpError, g as textPrompt, x as normalizeOutputError } from "./perf-metrics-D0um6IR6.js";
-import { B as serializeSessionRecordForDisk, G as DEFAULT_AGENT_NAME, J as resolveAgentCommand, K as listBuiltInAgents, M as parseSessionRecord, P as defaultSessionEventLog, W as withTimeout, _ as recordSessionUpdate, a as applyConversation, f as cloneSessionAcpxState, g as recordPromptSubmission, h as recordClientOperation, i as connectAndLoadSession, l as setDesiredModeId, m as createSessionConversation, n as withConnectedSession, o as applyLifecycleSnapshotToRecord, p as cloneSessionConversation, s as reconcileAgentSessionId, t as runPromptTurn, v as trimConversationForRuntime, y as AcpClient, z as assertPersistedKeyPolicy } from "./prompt-turn-CXMtXBl-.js";
+import { C as isAcpResourceNotFoundError, S as extractAcpError, g as textPrompt, x as normalizeOutputError } from "./perf-metrics-C2pXfxvR.js";
+import { I as parseSessionRecord, J as withTimeout, Q as resolveAgentCommand, R as defaultSessionEventLog, S as AcpClient, U as assertPersistedKeyPolicy, W as serializeSessionRecordForDisk, X as listBuiltInAgents, Y as DEFAULT_AGENT_NAME, _ as createSessionConversation, a as connectAndLoadSession, b as recordSessionUpdate, c as reconcileAgentSessionId, d as setDesiredConfigOption, f as setDesiredModeId, g as cloneSessionConversation, h as cloneSessionAcpxState, n as withConnectedSession, o as applyConversation, s as applyLifecycleSnapshotToRecord, t as runPromptTurn, v as recordClientOperation, x as trimConversationForRuntime, y as recordPromptSubmission } from "./prompt-turn-BY5SwU1F.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -31,9 +31,6 @@ function asString(value) {
 function asOptionalString(value) {
 	return asTrimmedString(value) || void 0;
 }
-function asOptionalBoolean(value) {
-	return typeof value === "boolean" ? value : void 0;
-}
 function deriveAgentFromSessionKey(sessionKey, fallbackAgent) {
 	const match = sessionKey.match(/^agent:([^:]+):/i);
 	return (match?.[1] ? asTrimmedString(match[1]) : "") || fallbackAgent;
@@ -133,13 +130,54 @@ function createTextDeltaEvent(params) {
 		...params.tag ? { tag: params.tag } : {}
 	};
 }
+function readFirstString(record, keys) {
+	for (const key of keys) {
+		const value = asOptionalString(record[key]);
+		if (value) return value;
+	}
+}
+function readFirstStringArray(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (!Array.isArray(value)) continue;
+		const entries = value.map((entry) => asOptionalString(entry)).filter((entry) => entry !== void 0);
+		if (entries.length > 0) return entries;
+	}
+}
+function summarizeToolInput(rawInput) {
+	if (rawInput == null) return;
+	if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") return String(rawInput);
+	if (!isRecord(rawInput)) return;
+	const command = readFirstString(rawInput, [
+		"command",
+		"cmd",
+		"program"
+	]);
+	const args = readFirstStringArray(rawInput, ["args", "arguments"]);
+	if (command) return [command, ...args ?? []].join(" ");
+	return readFirstString(rawInput, [
+		"path",
+		"file",
+		"filePath",
+		"filepath",
+		"target",
+		"uri",
+		"url",
+		"query",
+		"pattern",
+		"text",
+		"search"
+	]);
+}
 function createToolCallEvent(params) {
 	const title = asTrimmedString(params.payload.title) || "tool call";
 	const status = asTrimmedString(params.payload.status);
+	const inputSummary = summarizeToolInput(params.payload.rawInput);
 	const toolCallId = asOptionalString(params.payload.toolCallId);
+	const summaryText = status ? `${title} (${status})` : title;
 	return {
 		type: "tool_call",
-		text: status ? `${title} (${status})` : title,
+		text: inputSummary ? `${summaryText}: ${inputSummary}` : summaryText,
 		tag: params.tag,
 		...toolCallId ? { toolCallId } : {},
 		...status ? { status } : {},
@@ -236,16 +274,8 @@ function parsePromptEventLine(line) {
 				...tag ? { tag } : {}
 			};
 		}
-		case "done": return {
-			type: "done",
-			stopReason: asOptionalString(payload.stopReason)
-		};
-		case "error": return {
-			type: "error",
-			message: asTrimmedString(payload.message) || "acpx runtime error",
-			code: asOptionalString(payload.code),
-			retryable: asOptionalBoolean(payload.retryable)
-		};
+		case "done":
+		case "error": return null;
 		default: return null;
 	}
 }
@@ -272,6 +302,12 @@ function createDeferred() {
 		reject
 	};
 }
+function applyConfigOptionsToRecord(record, configOptions) {
+	if (!configOptions) return;
+	const acpxState = cloneSessionAcpxState(record.acpx) ?? {};
+	acpxState.config_options = structuredClone(configOptions);
+	record.acpx = acpxState;
+}
 var AsyncEventQueue = class {
 	items = [];
 	waits = [];
@@ -290,6 +326,9 @@ var AsyncEventQueue = class {
 		this.closed = true;
 		for (const waiter of this.waits.splice(0)) waiter.resolve(null);
 	}
+	clear() {
+		this.items.length = 0;
+	}
 	async next() {
 		if (this.items.length > 0) return this.items.shift() ?? null;
 		if (this.closed) return null;
@@ -360,6 +399,18 @@ function createRecordId(sessionKey, mode) {
 function resumePolicyForSessionMode(mode) {
 	return mode === "persistent" ? "same-session-only" : "allow-new";
 }
+function legacyTerminalEventFromTurnResult(result) {
+	if (result.status === "failed") return {
+		type: "error",
+		message: result.error.message,
+		...result.error.code ? { code: result.error.code } : {},
+		...result.error.retryable === void 0 ? {} : { retryable: result.error.retryable }
+	};
+	return {
+		type: "done",
+		...result.stopReason ? { stopReason: result.stopReason } : {}
+	};
+}
 function statusSummary(record) {
 	return [
 		`session=${record.acpxRecordId}`,
@@ -372,6 +423,7 @@ function statusSummary(record) {
 var AcpRuntimeManager = class {
 	activeControllers = /* @__PURE__ */ new Map();
 	pendingPersistentClients = /* @__PURE__ */ new Map();
+	closingActiveRecords = /* @__PURE__ */ new Set();
 	constructor(options, deps = {}) {
 		this.options = options;
 		this.deps = deps;
@@ -379,6 +431,79 @@ var AcpRuntimeManager = class {
 	createClient(options) {
 		return this.deps.clientFactory?.(options) ?? new AcpClient(options);
 	}
+	async readPendingPersistentClient(record, options) {
+		const pendingClient = this.pendingPersistentClients.get(record.acpxRecordId);
+		if (!pendingClient) return;
+		if (!pendingClient.hasReusableSession(record.acpSessionId)) {
+			this.pendingPersistentClients.delete(record.acpxRecordId);
+			await pendingClient.close().catch(() => {});
+			return;
+		}
+		if (options.consume) this.pendingPersistentClients.delete(record.acpxRecordId);
+		return pendingClient;
+	}
+	async closePendingPersistentClient(recordId) {
+		const pendingClient = this.pendingPersistentClients.get(recordId);
+		if (!pendingClient) return;
+		this.pendingPersistentClients.delete(recordId);
+		await pendingClient.close().catch(() => {});
+	}
+	async refreshClosedState(record) {
+		if (!this.closingActiveRecords.has(record.acpxRecordId)) return record.closed === true;
+		const latest = await this.options.sessionStore.load(record.acpxRecordId).catch(() => void 0);
+		record.closed = true;
+		record.closedAt = latest?.closedAt ?? record.closedAt ?? isoNow();
+		if (latest?.acpx) record.acpx = {
+			...record.acpx,
+			...latest.acpx
+		};
+		return true;
+	}
+	async retainPersistentClientAfterTurn(input) {
+		const { record, client } = input;
+		if (!!record.acpxRecordId.includes(":oneshot:") || record.closed || !client.hasReusableSession(record.acpSessionId)) return false;
+		const previousClient = this.pendingPersistentClients.get(record.acpxRecordId);
+		this.pendingPersistentClients.set(record.acpxRecordId, client);
+		if (previousClient && previousClient !== client) await previousClient.close().catch(() => {});
+		return true;
+	}
+	async withRuntimeControlSession(record, sessionMode, run) {
+		const pendingClient = await this.readPendingPersistentClient(record, { consume: false });
+		if (pendingClient) {
+			const value = await run({
+				client: pendingClient,
+				sessionId: record.acpSessionId,
+				record
+			});
+			record.lastUsedAt = isoNow();
+			record.closed = false;
+			record.closedAt = void 0;
+			record.protocolVersion = pendingClient.initializeResult?.protocolVersion;
+			record.agentCapabilities = pendingClient.initializeResult?.agentCapabilities;
+			applyLifecycleSnapshotToRecord(record, pendingClient.getAgentLifecycleSnapshot());
+			return {
+				value,
+				record
+			};
+		}
+		const result = await withConnectedSession({
+			sessionRecordId: record.acpxRecordId,
+			loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
+			saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
+			createClient: (options) => this.createClient(options),
+			mcpServers: [...this.options.mcpServers ?? []],
+			permissionMode: this.options.permissionMode,
+			nonInteractivePermissions: this.options.nonInteractivePermissions,
+			verbose: this.options.verbose,
+			timeoutMs: this.options.timeoutMs,
+			resumePolicy: resumePolicyForSessionMode(sessionMode),
+			run
+		});
+		return {
+			value: result.value,
+			record: result.record
+		};
+	}
 	async ensureSession(input) {
 		const cwd = path.resolve(input.cwd?.trim() || this.options.cwd);
 		const agentCommand = this.options.agentRegistry.resolve(input.agent);
@@ -390,6 +515,7 @@ var AcpRuntimeManager = class {
 		})) {
 			existing.closed = false;
 			existing.closedAt = void 0;
+			this.closingActiveRecords.delete(existing.acpxRecordId);
 			await this.options.sessionStore.save(existing);
 			return existing;
 		}
@@ -423,6 +549,7 @@ var AcpRuntimeManager = class {
 				cwd,
 				agentSessionId
 			});
+			this.closingActiveRecords.delete(record.acpxRecordId);
 			record.protocolVersion = client.initializeResult?.protocolVersion;
 			record.agentCapabilities = client.initializeResult?.agentCapabilities;
 			applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
@@ -438,86 +565,143 @@ var AcpRuntimeManager = class {
 			if (!keepClientOpen) await client.close();
 		}
 	}
-	async *runTurn(input) {
-		const record = await this.requireRecord(input.handle.acpxRecordId ?? input.handle.sessionKey);
-		const conversation = cloneSessionConversation(record);
-		let acpxState = cloneSessionAcpxState(record.acpx);
+	startTurn(input) {
 		const promptInput = toPromptInput(input.text, input.attachments);
-		const promptMessageId = recordPromptSubmission(conversation, promptInput, isoNow());
-		trimConversationForRuntime(conversation);
 		const queue = new AsyncEventQueue();
-		let pendingClient = this.pendingPersistentClients.get(record.acpxRecordId);
-		if (pendingClient) {
-			this.pendingPersistentClients.delete(record.acpxRecordId);
-			if (!pendingClient.hasReusableSession(record.acpSessionId)) {
-				await pendingClient.close().catch(() => {});
-				pendingClient = void 0;
-			}
-		}
-		const client = pendingClient ?? this.createClient({
-			agentCommand: record.agentCommand,
-			cwd: record.cwd,
-			mcpServers: [...this.options.mcpServers ?? []],
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			verbose: this.options.verbose
-		});
-		let activeSessionId = record.acpSessionId;
-		let sawDone = false;
-		let pendingCancel = false;
-		let turnActive = true;
+		const result = createDeferred();
 		const sessionReady = createDeferred();
 		sessionReady.promise.catch(() => {});
-		const applyPendingCancel = async () => {
-			if (!pendingCancel || !client.hasActivePrompt()) return false;
-			const cancelled = await client.requestCancelActivePrompt();
-			if (cancelled) pendingCancel = false;
-			return cancelled;
+		let resultSettled = false;
+		let pendingCancel = false;
+		let turnActive = true;
+		let streamClosed = false;
+		let activeController = null;
+		const settleResult = (next) => {
+			if (resultSettled) return;
+			resultSettled = true;
+			result.resolve(next);
 		};
-		const activeController = {
-			hasActivePrompt: () => client.hasActivePrompt(),
-			requestCancelActivePrompt: async () => {
-				if (client.hasActivePrompt()) return await client.requestCancelActivePrompt();
-				if (!turnActive) return false;
-				pendingCancel = true;
-				return true;
-			},
-			setSessionMode: async (modeId) => {
-				if (!client.hasActivePrompt()) await sessionReady.promise;
-				await client.setSessionMode(activeSessionId, modeId);
-			},
-			setSessionModel: async (modelId) => {
-				if (!client.hasActivePrompt()) await sessionReady.promise;
-				await client.setSessionModel(activeSessionId, modelId);
-			},
-			setSessionConfigOption: async (configId, value) => {
-				if (!client.hasActivePrompt()) await sessionReady.promise;
-				return await client.setSessionConfigOption(activeSessionId, configId, value);
-			}
+		const closeStream = () => {
+			if (streamClosed) return;
+			streamClosed = true;
+			queue.clear();
+			queue.close();
 		};
-		const emitParsed = (payload) => {
-			const parsed = parsePromptEventLine(JSON.stringify(payload));
-			if (!parsed) return;
-			if (parsed.type === "done") sawDone = true;
-			queue.push(parsed);
+		const requestCancel = async () => {
+			if (activeController) return await activeController.requestCancelActivePrompt();
+			if (!turnActive) return false;
+			pendingCancel = true;
+			return true;
 		};
 		const abortHandler = () => {
-			activeController.requestCancelActivePrompt();
+			requestCancel();
 		};
 		if (input.signal) {
 			if (input.signal.aborted) {
-				queue.close();
-				return;
+				closeStream();
+				settleResult({
+					status: "cancelled",
+					stopReason: "cancelled"
+				});
+				return {
+					requestId: input.requestId,
+					events: queue.iterate(),
+					result: result.promise,
+					cancel: async () => {},
+					closeStream: async () => {}
+				};
 			}
 			input.signal.addEventListener("abort", abortHandler, { once: true });
 		}
-		this.activeControllers.set(record.acpxRecordId, activeController);
 		(async () => {
+			let record = null;
+			let conversation = null;
+			let acpxState;
+			let client = null;
 			try {
-				client.setEventHandlers({
+				record = await this.requireRecord(input.handle.acpxRecordId ?? input.handle.sessionKey);
+				conversation = cloneSessionConversation(record);
+				acpxState = cloneSessionAcpxState(record.acpx);
+				const promptStartedAt = isoNow();
+				const promptMessageId = recordPromptSubmission(conversation, promptInput, promptStartedAt);
+				trimConversationForRuntime(conversation);
+				record.lastPromptAt = promptStartedAt;
+				record.lastUsedAt = promptStartedAt;
+				record.acpx = acpxState;
+				applyConversation(record, conversation);
+				await this.options.sessionStore.save(record);
+				const pendingClient = await this.readPendingPersistentClient(record, { consume: true });
+				client = pendingClient ?? this.createClient({
+					agentCommand: record.agentCommand,
+					cwd: record.cwd,
+					mcpServers: [...this.options.mcpServers ?? []],
+					permissionMode: this.options.permissionMode,
+					nonInteractivePermissions: this.options.nonInteractivePermissions,
+					verbose: this.options.verbose
+				});
+				const runtimeClient = client;
+				const runtimeConversation = conversation;
+				const runtimeRecord = record;
+				let activeSessionId = record.acpSessionId;
+				const applyPendingCancel = async () => {
+					if (!pendingCancel || !runtimeClient.hasActivePrompt()) return false;
+					const cancelled = await runtimeClient.requestCancelActivePrompt();
+					if (cancelled) pendingCancel = false;
+					return cancelled;
+				};
+				activeController = {
+					hasActivePrompt: () => runtimeClient.hasActivePrompt(),
+					requestCancelActivePrompt: async () => {
+						if (runtimeClient.hasActivePrompt()) return await runtimeClient.requestCancelActivePrompt();
+						if (!turnActive) return false;
+						pendingCancel = true;
+						return true;
+					},
+					setSessionMode: async (modeId) => {
+						if (!runtimeClient.hasActivePrompt()) await sessionReady.promise;
+						await runtimeClient.setSessionMode(activeSessionId, modeId);
+						const nextState = cloneSessionAcpxState(acpxState) ?? {};
+						nextState.desired_mode_id = modeId;
+						acpxState = nextState;
+					},
+					setSessionModel: async (modelId) => {
+						if (!runtimeClient.hasActivePrompt()) await sessionReady.promise;
+						await runtimeClient.setSessionModel(activeSessionId, modelId);
+					},
+					setSessionConfigOption: async (configId, value) => {
+						if (!runtimeClient.hasActivePrompt()) await sessionReady.promise;
+						const response = await runtimeClient.setSessionConfigOption(activeSessionId, configId, value);
+						if (response?.configOptions) {
+							const nextState = cloneSessionAcpxState(acpxState) ?? {};
+							nextState.config_options = structuredClone(response.configOptions);
+							acpxState = nextState;
+						}
+						if (configId === "mode") {
+							const nextState = cloneSessionAcpxState(acpxState) ?? {};
+							nextState.desired_mode_id = value;
+							acpxState = nextState;
+						} else if (configId !== "model") {
+							const nextState = cloneSessionAcpxState(acpxState) ?? {};
+							nextState.desired_config_options = {
+								...nextState.desired_config_options,
+								[configId]: value
+							};
+							acpxState = nextState;
+						}
+						return response;
+					}
+				};
+				const emitParsed = (payload) => {
+					if (streamClosed) return;
+					const parsed = parsePromptEventLine(JSON.stringify(payload));
+					if (!parsed) return;
+					queue.push(parsed);
+				};
+				this.activeControllers.set(runtimeRecord.acpxRecordId, activeController);
+				runtimeClient.setEventHandlers({
 					onSessionUpdate: (notification) => {
-						acpxState = recordSessionUpdate(conversation, acpxState, notification);
-						trimConversationForRuntime(conversation);
+						acpxState = recordSessionUpdate(runtimeConversation, acpxState, notification);
+						trimConversationForRuntime(runtimeConversation);
 						emitParsed({
 							jsonrpc: "2.0",
 							method: "session/update",
@@ -525,8 +709,8 @@ var AcpRuntimeManager = class {
 						});
 					},
 					onClientOperation: (operation) => {
-						acpxState = recordClientOperation(conversation, acpxState, operation);
-						trimConversationForRuntime(conversation);
+						acpxState = recordClientOperation(runtimeConversation, acpxState, operation);
+						trimConversationForRuntime(runtimeConversation);
 						emitParsed({
 							type: "client_operation",
 							...operation
@@ -538,13 +722,14 @@ var AcpRuntimeManager = class {
 					resumed: false,
 					loadError: void 0
 				} : await connectAndLoadSession({
-					client,
-					record,
+					client: runtimeClient,
+					record: runtimeRecord,
 					resumePolicy: resumePolicyForSessionMode(input.sessionMode),
 					timeoutMs: this.options.timeoutMs,
 					activeController,
 					onClientAvailable: (controller) => {
-						this.activeControllers.set(record.acpxRecordId, controller);
+						activeController = controller;
+						this.activeControllers.set(runtimeRecord.acpxRecordId, controller);
 					},
 					onConnectedRecord: (connectedRecord) => {
 						connectedRecord.lastPromptAt = isoNow();
@@ -554,68 +739,96 @@ var AcpRuntimeManager = class {
 					}
 				});
 				sessionReady.resolve();
-				record.lastRequestId = input.requestId;
-				record.lastPromptAt = isoNow();
-				record.closed = false;
-				record.closedAt = void 0;
-				record.lastUsedAt = isoNow();
+				runtimeRecord.lastRequestId = input.requestId;
+				runtimeRecord.lastPromptAt = isoNow();
+				runtimeRecord.closed = false;
+				runtimeRecord.closedAt = void 0;
+				runtimeRecord.lastUsedAt = isoNow();
 				if (resumed || loadError) emitParsed({
 					type: "status",
 					text: loadError ? `load fallback: ${loadError}` : "session resumed"
 				});
 				if (pendingCancel || input.signal?.aborted) {
 					pendingCancel = false;
-					if (!sawDone) queue.push({
-						type: "done",
+					settleResult({
+						status: "cancelled",
 						stopReason: "cancelled"
 					});
 					return;
 				}
 				await applyPendingCancel();
 				const response = await runPromptTurn({
-					client,
+					client: runtimeClient,
 					sessionId,
 					prompt: promptInput,
 					timeoutMs: input.timeoutMs ?? this.options.timeoutMs,
-					conversation,
+					conversation: runtimeConversation,
 					promptMessageId
 				});
-				record.acpSessionId = activeSessionId;
-				reconcileAgentSessionId(record, record.agentSessionId);
-				record.protocolVersion = client.initializeResult?.protocolVersion;
-				record.agentCapabilities = client.initializeResult?.agentCapabilities;
-				record.acpx = acpxState;
-				applyConversation(record, conversation);
-				applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-				await this.options.sessionStore.save(record);
-				if (!sawDone) queue.push({
-					type: "done",
-					stopReason: response.stopReason
+				runtimeRecord.acpSessionId = activeSessionId;
+				reconcileAgentSessionId(runtimeRecord, runtimeRecord.agentSessionId);
+				runtimeRecord.protocolVersion = runtimeClient.initializeResult?.protocolVersion;
+				runtimeRecord.agentCapabilities = runtimeClient.initializeResult?.agentCapabilities;
+				runtimeRecord.acpx = acpxState;
+				applyConversation(runtimeRecord, runtimeConversation);
+				applyLifecycleSnapshotToRecord(runtimeRecord, runtimeClient.getAgentLifecycleSnapshot());
+				await this.options.sessionStore.save(runtimeRecord);
+				settleResult({
+					status: response.stopReason === "cancelled" ? "cancelled" : "completed",
+					...response.stopReason ? { stopReason: response.stopReason } : {}
 				});
 			} catch (error) {
 				sessionReady.reject(error);
 				const normalized = normalizeOutputError(error, { origin: "runtime" });
-				queue.push({
-					type: "error",
-					message: normalized.message,
-					code: normalized.code,
-					retryable: normalized.retryable
+				settleResult({
+					status: "failed",
+					error: {
+						message: normalized.message,
+						...normalized.code ? { code: normalized.code } : {},
+						...normalized.retryable !== void 0 ? { retryable: normalized.retryable } : {}
+					}
 				});
 			} finally {
 				turnActive = false;
 				if (input.signal) input.signal.removeEventListener("abort", abortHandler);
-				this.activeControllers.delete(record.acpxRecordId);
-				client.clearEventHandlers();
-				applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-				record.acpx = acpxState;
-				applyConversation(record, conversation);
-				record.lastUsedAt = isoNow();
-				await this.options.sessionStore.save(record).catch(() => {});
-				await client.close().catch(() => {});
+				client?.clearEventHandlers();
+				let pooled = false;
+				if (record && conversation) {
+					applyLifecycleSnapshotToRecord(record, client?.getAgentLifecycleSnapshot() ?? { running: false });
+					record.acpx = acpxState;
+					applyConversation(record, conversation);
+					record.lastUsedAt = isoNow();
+					const closed = await this.refreshClosedState(record);
+					await this.options.sessionStore.save(record).catch(() => {});
+					if (!closed && client) pooled = await this.retainPersistentClientAfterTurn({
+						record,
+						client
+					});
+				}
+				if (!pooled) await client?.close().catch(() => {});
+				if (record) {
+					this.activeControllers.delete(record.acpxRecordId);
+					this.closingActiveRecords.delete(record.acpxRecordId);
+				}
 				queue.close();
 			}
 		})();
-		yield* queue.iterate();
+		return {
+			requestId: input.requestId,
+			events: queue.iterate(),
+			result: result.promise,
+			cancel: async () => {
+				await requestCancel();
+			},
+			closeStream: async () => {
+				closeStream();
+			}
+		};
+	}
+	async *runTurn(input) {
+		const turn = this.startTurn(input);
+		yield* turn.events;
+		yield legacyTerminalEventFromTurnResult(await turn.result);
 	}
 	async getStatus(handle) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
@@ -627,7 +840,8 @@ var AcpRuntimeManager = class {
 			details: {
 				cwd: record.cwd,
 				lastUsedAt: record.lastUsedAt,
-				closed: record.closed === true
+				closed: record.closed === true,
+				...record.acpx?.config_options !== void 0 ? { configOptions: structuredClone(record.acpx.config_options) } : {}
 			}
 		};
 	}
@@ -636,20 +850,8 @@ var AcpRuntimeManager = class {
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		let targetRecord = record;
 		if (controller) await controller.setSessionMode(mode);
-		else targetRecord = (await withConnectedSession({
-			sessionRecordId: record.acpxRecordId,
-			loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
-			saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
-			createClient: (options) => this.createClient(options),
-			mcpServers: [...this.options.mcpServers ?? []],
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			verbose: this.options.verbose,
-			timeoutMs: this.options.timeoutMs,
-			resumePolicy: resumePolicyForSessionMode(sessionMode),
-			run: async ({ client, sessionId }) => {
-				await client.setSessionMode(sessionId, mode);
-			}
+		else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId }) => {
+			await client.setSessionMode(sessionId, mode);
 		})).record;
 		setDesiredModeId(targetRecord, mode);
 		await this.options.sessionStore.save(targetRecord);
@@ -658,24 +860,16 @@ var AcpRuntimeManager = class {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		let targetRecord = record;
-		if (controller) await controller.setSessionConfigOption(key, value);
-		else targetRecord = (await withConnectedSession({
-			sessionRecordId: record.acpxRecordId,
-			loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
-			saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
-			createClient: (options) => this.createClient(options),
-			mcpServers: [...this.options.mcpServers ?? []],
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			verbose: this.options.verbose,
-			timeoutMs: this.options.timeoutMs,
-			resumePolicy: resumePolicyForSessionMode(sessionMode),
-			run: async ({ client, sessionId, record: connectedRecord }) => {
-				await client.setSessionConfigOption(sessionId, key, value);
-				if (key === "mode") setDesiredModeId(connectedRecord, value);
-			}
+		if (controller) {
+			const response = await controller.setSessionConfigOption(key, value);
+			applyConfigOptionsToRecord(targetRecord, response?.configOptions);
+		} else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
+			applyConfigOptionsToRecord(connectedRecord, (await client.setSessionConfigOption(sessionId, key, value))?.configOptions);
+			if (key === "mode") setDesiredModeId(connectedRecord, value);
+			else setDesiredConfigOption(connectedRecord, key, value);
 		})).record;
 		if (key === "mode") setDesiredModeId(targetRecord, value);
+		else setDesiredConfigOption(targetRecord, key, value);
 		await this.options.sessionStore.save(targetRecord);
 	}
 	async cancel(handle) {
@@ -683,6 +877,7 @@ var AcpRuntimeManager = class {
 	}
 	async close(handle, options = {}) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		if (this.activeControllers.has(record.acpxRecordId)) this.closingActiveRecords.add(record.acpxRecordId);
 		await this.cancel(handle);
 		if (options.discardPersistentState) {
 			await this.closeBackendSession(record);
@@ -690,17 +885,14 @@ var AcpRuntimeManager = class {
 				...record.acpx,
 				reset_on_next_ensure: true
 			};
-		}
+		} else await this.closePendingPersistentClient(record.acpxRecordId);
 		record.closed = true;
 		record.closedAt = isoNow();
 		await this.options.sessionStore.save(record);
 	}
 	async closeBackendSession(record) {
-		const pendingClient = this.pendingPersistentClients.get(record.acpxRecordId);
-		if (pendingClient) this.pendingPersistentClients.delete(record.acpxRecordId);
-		const reusablePendingClient = pendingClient?.hasReusableSession(record.acpSessionId) === true ? pendingClient : void 0;
-		if (pendingClient && !reusablePendingClient) await pendingClient.close().catch(() => {});
-		const client = reusablePendingClient ?? this.createClient({
+		const pendingClient = await this.readPendingPersistentClient(record, { consume: true });
+		const client = pendingClient ?? this.createClient({
 			agentCommand: record.agentCommand,
 			cwd: record.cwd,
 			mcpServers: [...this.options.mcpServers ?? []],
@@ -709,7 +901,7 @@ var AcpRuntimeManager = class {
 			verbose: this.options.verbose
 		});
 		try {
-			if (!reusablePendingClient) await withTimeout(client.start(), this.options.timeoutMs);
+			if (!pendingClient) await withTimeout(client.start(), this.options.timeoutMs);
 			if (!client.supportsCloseSession()) throw new AcpRuntimeError("ACP_BACKEND_UNSUPPORTED_CONTROL", `Agent does not support session/close for ${record.acpxRecordId}.`);
 			await withTimeout(client.closeSession(record.acpSessionId), this.options.timeoutMs);
 		} catch (error) {
@@ -807,6 +999,28 @@ function writeHandleState(handle, state) {
 }
 //#endregion
 //#region src/runtime/public/probe.ts
+function formatRuntimeDetail(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	if (value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
+	if (typeof value === "function") return value.name ? `[Function ${value.name}]` : "[Function]";
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_key, nested) => {
+			if (nested instanceof Error) return nested.message || nested.name;
+			if (nested && typeof nested === "object") {
+				if (seen.has(nested)) return "[Circular]";
+				seen.add(nested);
+			}
+			return nested;
+		}) ?? "undefined";
+	} catch {
+		return "unserializable object";
+	}
+}
+function normalizeRuntimeDetails(details) {
+	return details?.map((detail) => formatRuntimeDetail(detail));
+}
 async function probeRuntime(options, deps = {}) {
 	const agentName = options.probeAgent?.trim() || "codex";
 	const agentCommand = options.agentRegistry.resolve(agentName);
@@ -845,7 +1059,7 @@ async function probeRuntime(options, deps = {}) {
 				`agent=${agentName}`,
 				`command=${agentCommand}`,
 				`cwd=${options.cwd}`,
-				error instanceof Error ? error.message : String(error)
+				formatRuntimeDetail(error)
 			]
 		};
 	} finally {
@@ -882,7 +1096,8 @@ var AcpxRuntime = class {
 		return this.healthy;
 	}
 	async probeAvailability() {
-		this.healthy = (await this.runProbe()).ok;
+		const report = await this.runProbe();
+		this.healthy = report.ok;
 	}
 	async doctor() {
 		const report = await this.runProbe();
@@ -891,7 +1106,7 @@ var AcpxRuntime = class {
 			ok: report.ok,
 			code: report.ok ? void 0 : "ACP_BACKEND_UNAVAILABLE",
 			message: report.message,
-			details: report.details
+			details: normalizeRuntimeDetails(report.details)
 		};
 	}
 	async ensureSession(input) {
@@ -926,13 +1141,38 @@ var AcpxRuntime = class {
 		});
 		return handle;
 	}
+	startTurn(input) {
+		const { handle, state } = this.resolveManagerHandle(input.handle);
+		const turnPromise = this.getManager().then((manager) => manager.startTurn({
+			handle,
+			text: input.text,
+			attachments: input.attachments,
+			mode: input.mode,
+			sessionMode: state.mode,
+			requestId: input.requestId,
+			timeoutMs: input.timeoutMs,
+			signal: input.signal
+		}));
+		return {
+			requestId: input.requestId,
+			events: { async *[Symbol.asyncIterator]() {
+				yield* (await turnPromise).events;
+			} },
+			get result() {
+				return turnPromise.then((turn) => turn.result);
+			},
+			cancel(inputArgs) {
+				return turnPromise.then((turn) => turn.cancel(inputArgs));
+			},
+			closeStream(inputArgs) {
+				return turnPromise.then((turn) => turn.closeStream(inputArgs));
+			}
+		};
+	}
 	async *runTurn(input) {
-		const state = this.resolveHandleState(input.handle);
+		const { handle, state } = this.resolveManagerHandle(input.handle);
 		yield* (await this.getManager()).runTurn({
-			handle: {
-				...input.handle,
-				acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-			},
+			handle,
 			text: input.text,
 			attachments: input.attachments,
 			mode: input.mode,
@@ -942,43 +1182,28 @@ var AcpxRuntime = class {
 			signal: input.signal
 		});
 	}
-	getCapabilities() {
+	getCapabilities(_input) {
 		return ACPX_CAPABILITIES;
 	}
 	async getStatus(input) {
-		const state = this.resolveHandleState(input.handle);
-		return await (await this.getManager()).getStatus({
-			...input.handle,
-			acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-		});
+		const { handle } = this.resolveManagerHandle(input.handle);
+		return await (await this.getManager()).getStatus(handle);
 	}
 	async setMode(input) {
-		const state = this.resolveHandleState(input.handle);
-		await (await this.getManager()).setMode({
-			...input.handle,
-			acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-		}, input.mode, state.mode);
+		const { handle, state } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).setMode(handle, input.mode, state.mode);
 	}
 	async setConfigOption(input) {
-		const state = this.resolveHandleState(input.handle);
-		await (await this.getManager()).setConfigOption({
-			...input.handle,
-			acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-		}, input.key, input.value, state.mode);
+		const { handle, state } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).setConfigOption(handle, input.key, input.value, state.mode);
 	}
 	async cancel(input) {
-		const state = this.resolveHandleState(input.handle);
-		await (await this.getManager()).cancel({
-			...input.handle,
-			acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-		});
+		const { handle } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).cancel(handle);
 	}
 	async close(input) {
-		const state = this.resolveHandleState(input.handle);
-		await (await this.getManager()).close({
-			...input.handle,
-			acpxRecordId: state.acpxRecordId ?? input.handle.acpxRecordId ?? input.handle.sessionKey
-		}, { discardPersistentState: input.discardPersistentState });
+		const { handle } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).close(handle, { discardPersistentState: input.discardPersistentState });
 	}
 	async getManager() {
 		if (this.manager) return this.manager;
@@ -991,6 +1216,16 @@ var AcpxRuntime = class {
 	async runProbe() {
 		return await (this.testOptions?.probeRunner?.(this.options) ?? probeRuntime(this.options));
 	}
+	resolveManagerHandle(handle) {
+		const state = this.resolveHandleState(handle);
+		return {
+			handle: {
+				...handle,
+				acpxRecordId: state.acpxRecordId ?? handle.acpxRecordId ?? handle.sessionKey
+			},
+			state
+		};
+	}
 	resolveHandleState(handle) {
 		const decoded = decodeAcpxRuntimeHandleState(handle.runtimeSessionName);
 		if (decoded) return {