acpx 0.7.0 → 0.9.0

package/dist/runtime.js

@@ -1,5 +1,4 @@
-import { C as isAcpResourceNotFoundError, S as extractAcpError, g as textPrompt, x as normalizeOutputError } from "./perf-metrics-C2pXfxvR.js";
-import { $ as resolveAgentCommand, C as AcpClient, G as serializeSessionRecordForDisk, L as parseSessionRecord, S as trimConversationForRuntime, W as assertPersistedKeyPolicy, X as DEFAULT_AGENT_NAME, Y as withTimeout, Z as listBuiltInAgents, _ as cloneSessionConversation, a as connectAndLoadSession, b as recordPromptSubmission, c as reconcileAgentSessionId, d as setDesiredConfigOption, f as setDesiredModeId, g as cloneSessionAcpxState, h as applyConfigOptionsToRecord, n as withConnectedSession, o as applyConversation, s as applyLifecycleSnapshotToRecord, t as runPromptTurn, v as createSessionConversation, x as recordSessionUpdate, y as recordClientOperation, z as defaultSessionEventLog } from "./prompt-turn-CVPMWdj1.js";
+import { C as applyConversation, Dt as isAcpResourceNotFoundError, E as AcpClient, Et as extractAcpError, K as defaultSessionEventLog, T as reconcileAgentSessionId, Tt as normalizeOutputError, W as parseSessionRecord, Z as assertPersistedKeyPolicy, _ as recordPromptSubmission, _t as withTimeout, a as applyRequestedModelIfAdvertised, c as setDesiredConfigOption, d as syncAdvertisedModelState, f as applyConfigOptionsToRecord, g as recordClientOperation, h as createSessionConversation, i as connectAndLoadSession, l as setDesiredModeId, m as cloneSessionConversation, n as runPromptTurn, ot as serializeSessionRecordForDisk, p as cloneSessionAcpxState, pt as textPrompt, r as withConnectedSession, s as setCurrentModelId, t as LiveSessionCheckpoint, v as recordSessionUpdate, vt as DEFAULT_AGENT_NAME, w as applyLifecycleSnapshotToRecord, x as persistSessionOptions, xt as resolveAgentCommand, y as trimConversationForRuntime, yt as listBuiltInAgents } from "./live-checkpoint-D5d-K9s1.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -37,6 +36,7 @@ function deriveAgentFromSessionKey(sessionKey, fallbackAgent) {
 }
 //#endregion
 //#region src/runtime/public/events.ts
+const TOOL_OUTPUT_SUMMARY_MAX_CHARS = 500;
 function safeParseJsonObject(line) {
 	try {
 		const parsed = JSON.parse(line);
@@ -76,28 +76,36 @@ function resolveStructuredPromptPayload(parsed) {
 	};
 }
 function resolveStatusTextForTag(params) {
-	const { tag, payload } = params;
-	if (tag === "available_commands_update") {
-		const commands = Array.isArray(payload.availableCommands) ? payload.availableCommands : [];
-		return commands.length > 0 ? `available commands updated (${commands.length})` : "available commands updated";
-	}
-	if (tag === "current_mode_update") {
-		const mode = asTrimmedString(payload.currentModeId) || asTrimmedString(payload.modeId) || asTrimmedString(payload.mode);
-		return mode ? `mode updated: ${mode}` : "mode updated";
-	}
-	if (tag === "config_option_update") {
-		const id = asTrimmedString(payload.id) || asTrimmedString(payload.configOptionId);
-		const value = asTrimmedString(payload.currentValue) || asTrimmedString(payload.value) || asTrimmedString(payload.optionValue);
-		if (id && value) return `config updated: ${id}=${value}`;
-		if (id) return `config updated: ${id}`;
-		return "config updated";
-	}
-	if (tag === "session_info_update") return asTrimmedString(payload.summary) || asTrimmedString(payload.message) || "session updated";
-	if (tag === "plan") {
-		const content = asTrimmedString((Array.isArray(payload.entries) ? payload.entries : []).find((entry) => isRecord(entry))?.content);
-		return content ? `plan: ${content}` : null;
-	}
-	return null;
+	const resolver = STATUS_TEXT_RESOLVERS[params.tag];
+	return resolver ? resolver(params.payload) : null;
+}
+const STATUS_TEXT_RESOLVERS = {
+	available_commands_update: availableCommandsStatusText,
+	current_mode_update: currentModeStatusText,
+	config_option_update: configOptionStatusText,
+	session_info_update: sessionInfoStatusText,
+	plan: planStatusText
+};
+function availableCommandsStatusText(payload) {
+	const commands = Array.isArray(payload.availableCommands) ? payload.availableCommands : [];
+	return commands.length > 0 ? `available commands updated (${commands.length})` : "available commands updated";
+}
+function currentModeStatusText(payload) {
+	const mode = asTrimmedString(payload.currentModeId) || asTrimmedString(payload.modeId) || asTrimmedString(payload.mode);
+	return mode ? `mode updated: ${mode}` : "mode updated";
+}
+function configOptionStatusText(payload) {
+	const id = asTrimmedString(payload.id) || asTrimmedString(payload.configOptionId);
+	const value = asTrimmedString(payload.currentValue) || asTrimmedString(payload.value) || asTrimmedString(payload.optionValue);
+	if (id && value) return `config updated: ${id}=${value}`;
+	return id ? `config updated: ${id}` : "config updated";
+}
+function sessionInfoStatusText(payload) {
+	return asTrimmedString(payload.summary) || asTrimmedString(payload.message) || "session updated";
+}
+function planStatusText(payload) {
+	const content = asTrimmedString((Array.isArray(payload.entries) ? payload.entries : []).find((entry) => isRecord(entry))?.content);
+	return content ? `plan: ${content}` : null;
 }
 function resolveTextChunk(params) {
 	const contentRaw = params.payload.content;
@@ -169,20 +177,108 @@ function summarizeToolInput(rawInput) {
 		"search"
 	]);
 }
+function truncateToolSummary(value) {
+	if (value.length <= TOOL_OUTPUT_SUMMARY_MAX_CHARS) return value;
+	return `${value.slice(0, TOOL_OUTPUT_SUMMARY_MAX_CHARS - 1)}…`;
+}
+function readToolContentText(value) {
+	const record = isRecord(value) ? value : void 0;
+	if (!record) return;
+	if (record.type === "content") return readToolContentText(record.content);
+	return toolContentTextReader(String(record.type))?.(record);
+}
+const TOOL_CONTENT_TEXT_READERS = {
+	text: (record) => asString(record.text),
+	audio: (record) => `[audio] ${asOptionalString(record.mimeType) || "audio"}`,
+	resource_link: (record) => asOptionalString(record.title) || asOptionalString(record.name) || asOptionalString(record.uri),
+	resource: (record) => {
+		const resource = isRecord(record.resource) ? record.resource : void 0;
+		return asString(resource?.text) || asOptionalString(resource?.uri);
+	},
+	diff: (record) => `diff ${asOptionalString(record.path) || "file"}`,
+	terminal: (record) => {
+		const terminalId = asOptionalString(record.terminalId) || asOptionalString(record.id);
+		return terminalId ? `[terminal] ${terminalId}` : "[terminal]";
+	}
+};
+function toolContentTextReader(type) {
+	return Object.hasOwn(TOOL_CONTENT_TEXT_READERS, type) ? TOOL_CONTENT_TEXT_READERS[type] : void 0;
+}
+function summarizeToolContent(content) {
+	if (!Array.isArray(content)) return;
+	const fragments = content.map((entry) => readToolContentText(entry)?.trim()).filter((entry) => Boolean(entry));
+	if (fragments.length === 0) return;
+	return truncateToolSummary([...new Set(fragments)].join("\n"));
+}
+function summarizeToolOutput(rawOutput) {
+	if (rawOutput == null) return;
+	if (isScalarToolOutput(rawOutput)) return truncateToolSummary(String(rawOutput));
+	const record = isRecord(rawOutput) ? rawOutput : void 0;
+	if (!record) return;
+	return truncateToolSummary(readFirstString(record, [
+		"text",
+		"message",
+		"error",
+		"stdout",
+		"stderr",
+		"content"
+	]) ?? "") || void 0;
+}
+function isScalarToolOutput(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function shouldForwardArray(value) {
+	return Array.isArray(value);
+}
+function readToolKind(value) {
+	const kind = asOptionalString(value);
+	return kind && TOOL_KINDS.has(kind) ? kind : void 0;
+}
+const TOOL_KINDS = new Set([
+	"read",
+	"edit",
+	"delete",
+	"move",
+	"search",
+	"execute",
+	"fetch",
+	"think",
+	"other"
+]);
 function createToolCallEvent(params) {
 	const title = asTrimmedString(params.payload.title) || "tool call";
 	const status = asTrimmedString(params.payload.status);
 	const inputSummary = summarizeToolInput(params.payload.rawInput);
+	const outputSummary = summarizeToolContent(params.payload.content) ?? summarizeToolOutput(params.payload.rawOutput);
 	const toolCallId = asOptionalString(params.payload.toolCallId);
+	const kind = readToolKind(params.payload.kind);
 	const summaryText = status ? `${title} (${status})` : title;
-	return {
+	const detailSummary = params.tag === "tool_call_update" ? outputSummary ?? inputSummary : inputSummary ?? outputSummary;
+	const event = {
 		type: "tool_call",
-		text: inputSummary ? `${summaryText}: ${inputSummary}` : summaryText,
+		text: detailSummary ? `${summaryText}: ${detailSummary}` : summaryText,
 		tag: params.tag,
-		...toolCallId ? { toolCallId } : {},
-		...status ? { status } : {},
 		title
 	};
+	assignToolCallEventMetadata(event, params.payload, {
+		toolCallId,
+		status,
+		kind
+	});
+	return event;
+}
+function assignToolCallEventMetadata(event, payload, values) {
+	if (event.type !== "tool_call") return;
+	if (values.toolCallId) event.toolCallId = values.toolCallId;
+	if (values.status) event.status = values.status;
+	if (values.kind) event.kind = values.kind;
+	assignForwardedToolPayload(event, payload);
+}
+function assignForwardedToolPayload(event, payload) {
+	if (shouldForwardArray(payload.locations)) event.locations = payload.locations;
+	if (Object.prototype.hasOwnProperty.call(payload, "rawInput")) event.rawInput = payload.rawInput;
+	if (Object.prototype.hasOwnProperty.call(payload, "rawOutput")) event.rawOutput = payload.rawOutput;
+	if (shouldForwardArray(payload.content)) event.content = payload.content;
 }
 function parsePromptEventLine(line) {
 	const trimmed = line.trim();
@@ -196,88 +292,94 @@ function parsePromptEventLine(line) {
 	const type = structured.type;
 	const payload = structured.payload;
 	const tag = structured.tag;
-	switch (type) {
-		case "text": return createTextDeltaEvent({
-			content: asString(payload.content),
-			stream: "output",
-			tag
-		});
-		case "thought": return createTextDeltaEvent({
-			content: asString(payload.content),
-			stream: "thought",
-			tag
-		});
-		case "tool_call": return createToolCallEvent({
-			payload,
-			tag: tag ?? "tool_call"
-		});
-		case "tool_call_update": return createToolCallEvent({
-			payload,
-			tag: tag ?? "tool_call_update"
-		});
-		case "agent_message_chunk": return resolveTextChunk({
-			payload,
-			stream: "output",
-			tag: "agent_message_chunk"
-		});
-		case "agent_thought_chunk": return resolveTextChunk({
-			payload,
-			stream: "thought",
-			tag: "agent_thought_chunk"
-		});
-		case "usage_update": {
-			const used = asOptionalFiniteNumber(payload.used);
-			const size = asOptionalFiniteNumber(payload.size);
-			return {
-				type: "status",
-				text: used != null && size != null ? `usage updated: ${used}/${size}` : "usage updated",
-				tag: "usage_update",
-				...used != null ? { used } : {},
-				...size != null ? { size } : {}
-			};
-		}
-		case "available_commands_update":
-		case "current_mode_update":
-		case "config_option_update":
-		case "session_info_update":
-		case "plan": {
-			const text = resolveStatusTextForTag({
-				tag: type,
-				payload
-			});
-			if (!text) return null;
-			return {
-				type: "status",
-				text,
-				tag: type
-			};
-		}
-		case "client_operation": {
-			const text = [
-				asTrimmedString(payload.method) || "operation",
-				asTrimmedString(payload.status),
-				asTrimmedString(payload.summary)
-			].filter(Boolean).join(" ");
-			if (!text) return null;
-			return {
-				type: "status",
-				text,
-				...tag ? { tag } : {}
-			};
-		}
-		case "update": {
-			const update = asTrimmedString(payload.update);
-			if (!update) return null;
-			return {
-				type: "status",
-				text: update,
-				...tag ? { tag } : {}
-			};
-		}
-		case "done":
-		case "error": return null;
-		default: return null;
-	}
+	const parser = promptEventParser(type);
+	return parser ? parser(payload, tag) : null;
+}
+const PROMPT_EVENT_PARSERS = {
+	text: (payload, tag) => createTextDeltaEvent({
+		content: asString(payload.content),
+		stream: "output",
+		tag
+	}),
+	thought: (payload, tag) => createTextDeltaEvent({
+		content: asString(payload.content),
+		stream: "thought",
+		tag
+	}),
+	tool_call: (payload, tag) => createToolCallEvent({
+		payload,
+		tag: tag ?? "tool_call"
+	}),
+	tool_call_update: (payload, tag) => createToolCallEvent({
+		payload,
+		tag: tag ?? "tool_call_update"
+	}),
+	agent_message_chunk: (payload) => resolveTextChunk({
+		payload,
+		stream: "output",
+		tag: "agent_message_chunk"
+	}),
+	agent_thought_chunk: (payload) => resolveTextChunk({
+		payload,
+		stream: "thought",
+		tag: "agent_thought_chunk"
+	}),
+	usage_update: usageUpdateEvent,
+	available_commands_update: (payload) => statusUpdateEvent("available_commands_update", payload),
+	current_mode_update: (payload) => statusUpdateEvent("current_mode_update", payload),
+	config_option_update: (payload) => statusUpdateEvent("config_option_update", payload),
+	session_info_update: (payload) => statusUpdateEvent("session_info_update", payload),
+	plan: (payload) => statusUpdateEvent("plan", payload),
+	client_operation: clientOperationEvent,
+	update: updateStatusEvent,
+	done: () => null,
+	error: () => null
+};
+function promptEventParser(type) {
+	return Object.hasOwn(PROMPT_EVENT_PARSERS, type) ? PROMPT_EVENT_PARSERS[type] : void 0;
+}
+function usageUpdateEvent(payload) {
+	const used = asOptionalFiniteNumber(payload.used);
+	const size = asOptionalFiniteNumber(payload.size);
+	return {
+		type: "status",
+		text: used != null && size != null ? `usage updated: ${used}/${size}` : "usage updated",
+		tag: "usage_update",
+		...used != null ? { used } : {},
+		...size != null ? { size } : {}
+	};
+}
+function statusUpdateEvent(tag, payload) {
+	const text = resolveStatusTextForTag({
+		tag,
+		payload
+	});
+	if (!text) return null;
+	return {
+		type: "status",
+		text,
+		tag
+	};
+}
+function clientOperationEvent(payload, tag) {
+	const text = [
+		asTrimmedString(payload.method) || "operation",
+		asTrimmedString(payload.status),
+		asTrimmedString(payload.summary)
+	].filter(Boolean).join(" ");
+	return text ? {
+		type: "status",
+		text,
+		...tag ? { tag } : {}
+	} : null;
+}
+function updateStatusEvent(payload, tag) {
+	const update = asTrimmedString(payload.update);
+	return update ? {
+		type: "status",
+		text: update,
+		...tag ? { tag } : {}
+	} : null;
 }
 //#endregion
 //#region src/runtime/engine/reuse-policy.ts
@@ -357,12 +459,23 @@ function toPromptInput(text, attachments) {
 		text
 	});
 	for (const attachment of attachments) {
-		if (!attachment.mediaType.startsWith("image/")) throw new AcpRuntimeError("ACP_TURN_FAILED", `Unsupported ACP runtime attachment media type: ${attachment.mediaType}`);
-		blocks.push({
-			type: "image",
-			mimeType: attachment.mediaType,
-			data: attachment.data
-		});
+		if (attachment.mediaType.startsWith("image/")) {
+			blocks.push({
+				type: "image",
+				mimeType: attachment.mediaType,
+				data: attachment.data
+			});
+			continue;
+		}
+		if (attachment.mediaType.startsWith("audio/")) {
+			blocks.push({
+				type: "audio",
+				mimeType: attachment.mediaType,
+				data: attachment.data
+			});
+			continue;
+		}
+		throw new AcpRuntimeError("ACP_TURN_FAILED", `Unsupported ACP runtime attachment media type: ${attachment.mediaType}`);
 	}
 	return blocks.length > 0 ? blocks : textPrompt(text);
 }
@@ -415,7 +528,60 @@ function statusSummary(record) {
 		record.closed ? "closed" : "open"
 	].filter(Boolean).join(" ");
 }
+function buildModelsField(record) {
+	const available = record.acpx?.available_models;
+	const currentModelId = record.acpx?.current_model_id;
+	if (!available || available.length === 0) return currentModelId === void 0 ? {} : { models: {
+		currentModelId,
+		availableModelIds: []
+	} };
+	return { models: {
+		...currentModelId !== void 0 ? { currentModelId } : {},
+		availableModelIds: [...available]
+	} };
+}
+function advertisedConfigOptionIds(record) {
+	const configOptions = record.acpx?.config_options;
+	if (!configOptions) return;
+	return new Set(configOptions.map((option) => option.id).filter((id) => typeof id === "string" && id.trim().length > 0));
+}
+function resolveSupportedConfigOptionId(record, configId) {
+	const advertisedIds = advertisedConfigOptionIds(record);
+	if (!advertisedIds) return configId;
+	if (advertisedIds.has(configId)) return configId;
+	if (configId === "thinking" && advertisedIds.has("effort")) return "effort";
+	const supported = [...advertisedIds].toSorted();
+	const supportedText = supported.length > 0 ? supported.join(", ") : "none";
+	throw new AcpRuntimeError("ACP_BACKEND_UNSUPPORTED_CONTROL", `ACP session ${record.acpxRecordId} does not advertise config option '${configId}'. Supported config options: ${supportedText}.`);
+}
+async function createOrLoadRuntimeSession(client, resumeSessionId, cwd) {
+	if (resumeSessionId) {
+		if (client.supportsResumeSession()) {
+			const resumed = await client.resumeSession(resumeSessionId, cwd);
+			return {
+				sessionId: resumeSessionId,
+				agentSessionId: resumed.agentSessionId,
+				sessionResult: resumed
+			};
+		}
+		if (!client.supportsLoadSession()) throw new Error(`Agent does not support session/resume or session/load; cannot resume session ${resumeSessionId}`);
+		const loaded = await client.loadSession(resumeSessionId, cwd);
+		return {
+			sessionId: resumeSessionId,
+			agentSessionId: loaded.agentSessionId,
+			sessionResult: loaded
+		};
+	}
+	const created = await client.createSession(cwd);
+	return {
+		sessionId: created.sessionId,
+		agentSessionId: created.agentSessionId,
+		sessionResult: created
+	};
+}
 var AcpRuntimeManager = class {
+	options;
+	deps;
 	activeControllers = /* @__PURE__ */ new Map();
 	pendingPersistentClients = /* @__PURE__ */ new Map();
 	closingActiveRecords = /* @__PURE__ */ new Set();
@@ -489,6 +655,7 @@ var AcpRuntimeManager = class {
 			mcpServers: [...this.options.mcpServers ?? []],
 			permissionMode: this.options.permissionMode,
 			nonInteractivePermissions: this.options.nonInteractivePermissions,
+			onPermissionRequest: this.options.onPermissionRequest,
 			verbose: this.options.verbose,
 			timeoutMs: this.options.timeoutMs,
 			resumePolicy: resumePolicyForSessionMode(sessionMode),
@@ -520,50 +687,63 @@ var AcpRuntimeManager = class {
 			mcpServers: [...this.options.mcpServers ?? []],
 			permissionMode: this.options.permissionMode,
 			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			verbose: this.options.verbose
+			onPermissionRequest: this.options.onPermissionRequest,
+			verbose: this.options.verbose,
+			sessionOptions: input.sessionOptions
 		});
 		let keepClientOpen = false;
 		try {
 			await client.start();
-			let sessionId;
-			let agentSessionId;
-			let sessionResult;
-			if (input.resumeSessionId) {
-				const loaded = await client.loadSession(input.resumeSessionId, cwd);
-				sessionId = input.resumeSessionId;
-				agentSessionId = loaded.agentSessionId;
-				sessionResult = loaded;
-			} else {
-				const created = await client.createSession(cwd);
-				sessionId = created.sessionId;
-				agentSessionId = created.agentSessionId;
-				sessionResult = created;
-			}
-			const record = createInitialRecord({
-				recordId: createRecordId(input.sessionKey, input.mode),
-				sessionName: input.sessionKey,
-				sessionId,
+			const session = await createOrLoadRuntimeSession(client, input.resumeSessionId, cwd);
+			const record = await this.createAndSaveRuntimeRecord({
+				input,
+				client,
 				agentCommand,
 				cwd,
-				agentSessionId
+				session
 			});
-			this.closingActiveRecords.delete(record.acpxRecordId);
-			record.protocolVersion = client.initializeResult?.protocolVersion;
-			record.agentCapabilities = client.initializeResult?.agentCapabilities;
-			applyConfigOptionsToRecord(record, sessionResult);
-			applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-			await this.options.sessionStore.save(record);
-			if (input.mode === "persistent") {
-				const previousClient = this.pendingPersistentClients.get(record.acpxRecordId);
-				this.pendingPersistentClients.set(record.acpxRecordId, client);
-				keepClientOpen = true;
-				await previousClient?.close().catch(() => {});
-			}
+			keepClientOpen = await this.keepPersistentClient(input.mode, record.acpxRecordId, client);
 			return record;
 		} finally {
 			if (!keepClientOpen) await client.close();
 		}
 	}
+	async createAndSaveRuntimeRecord(params) {
+		const { input, client, agentCommand, cwd, session } = params;
+		const record = createInitialRecord({
+			recordId: createRecordId(input.sessionKey, input.mode),
+			sessionName: input.sessionKey,
+			sessionId: session.sessionId,
+			agentCommand,
+			cwd,
+			agentSessionId: session.agentSessionId
+		});
+		this.closingActiveRecords.delete(record.acpxRecordId);
+		record.protocolVersion = client.initializeResult?.protocolVersion;
+		record.agentCapabilities = client.initializeResult?.agentCapabilities;
+		applyConfigOptionsToRecord(record, session.sessionResult);
+		const requestedModelApplied = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId: session.sessionId,
+			requestedModel: input.sessionOptions?.model,
+			models: session.sessionResult.models,
+			agentCommand,
+			timeoutMs: this.options.timeoutMs
+		});
+		syncAdvertisedModelState(record, session.sessionResult.models);
+		if (requestedModelApplied) setCurrentModelId(record, input.sessionOptions?.model);
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		persistSessionOptions(record, input.sessionOptions);
+		await this.options.sessionStore.save(record);
+		return record;
+	}
+	async keepPersistentClient(mode, recordId, client) {
+		if (mode !== "persistent") return false;
+		const previousClient = this.pendingPersistentClients.get(recordId);
+		this.pendingPersistentClients.set(recordId, client);
+		await previousClient?.close().catch(() => {});
+		return true;
+	}
 	startTurn(input) {
 		const promptInput = toPromptInput(input.text, input.attachments);
 		const queue = new AsyncEventQueue();
@@ -571,10 +751,12 @@ var AcpRuntimeManager = class {
 		const sessionReady = createDeferred();
 		sessionReady.promise.catch(() => {});
 		let resultSettled = false;
-		let pendingCancel = false;
-		let turnActive = true;
+		const state = {
+			pendingCancel: false,
+			turnActive: true,
+			activeController: null
+		};
 		let streamClosed = false;
-		let activeController = null;
 		const settleResult = (next) => {
 			if (resultSettled) return;
 			resultSettled = true;
@@ -587,9 +769,9 @@ var AcpRuntimeManager = class {
 			queue.close();
 		};
 		const requestCancel = async () => {
-			if (activeController) return await activeController.requestCancelActivePrompt();
-			if (!turnActive) return false;
-			pendingCancel = true;
+			if (state.activeController) return await state.activeController.requestCancelActivePrompt();
+			if (!state.turnActive) return false;
+			state.pendingCancel = true;
 			return true;
 		};
 		const abortHandler = () => {
@@ -612,207 +794,15 @@ var AcpRuntimeManager = class {
 			}
 			input.signal.addEventListener("abort", abortHandler, { once: true });
 		}
-		(async () => {
-			let record = null;
-			let conversation = null;
-			let acpxState;
-			let client = null;
-			try {
-				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(runtimeConversation, acpxState, notification);
-						trimConversationForRuntime(runtimeConversation);
-						emitParsed({
-							jsonrpc: "2.0",
-							method: "session/update",
-							params: notification
-						});
-					},
-					onClientOperation: (operation) => {
-						acpxState = recordClientOperation(runtimeConversation, acpxState, operation);
-						trimConversationForRuntime(runtimeConversation);
-						emitParsed({
-							type: "client_operation",
-							...operation
-						});
-					}
-				});
-				const { sessionId, resumed, loadError } = pendingClient ? {
-					sessionId: record.acpSessionId,
-					resumed: false,
-					loadError: void 0
-				} : await connectAndLoadSession({
-					client: runtimeClient,
-					record: runtimeRecord,
-					resumePolicy: resumePolicyForSessionMode(input.sessionMode),
-					timeoutMs: this.options.timeoutMs,
-					activeController,
-					onClientAvailable: (controller) => {
-						activeController = controller;
-						this.activeControllers.set(runtimeRecord.acpxRecordId, controller);
-					},
-					onConnectedRecord: (connectedRecord) => {
-						connectedRecord.lastPromptAt = isoNow();
-					},
-					onSessionIdResolved: (sessionIdValue) => {
-						activeSessionId = sessionIdValue;
-					}
-				});
-				sessionReady.resolve();
-				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;
-					settleResult({
-						status: "cancelled",
-						stopReason: "cancelled"
-					});
-					return;
-				}
-				await applyPendingCancel();
-				const response = await runPromptTurn({
-					client: runtimeClient,
-					sessionId,
-					prompt: promptInput,
-					timeoutMs: input.timeoutMs ?? this.options.timeoutMs,
-					conversation: runtimeConversation,
-					promptMessageId
-				});
-				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" });
-				settleResult({
-					status: "failed",
-					error: {
-						message: normalized.message,
-						...normalized.code ? { code: normalized.code } : {},
-						...normalized.detailCode ? { detailCode: normalized.detailCode } : {},
-						...normalized.retryable !== void 0 ? { retryable: normalized.retryable } : {}
-					}
-				});
-			} finally {
-				turnActive = false;
-				if (input.signal) input.signal.removeEventListener("abort", abortHandler);
-				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();
-			}
-		})();
+		this.runRuntimeTurnTask({
+			input,
+			promptInput,
+			queue,
+			sessionReady,
+			state,
+			settleResult,
+			abortHandler
+		});
 		return {
 			requestId: input.requestId,
 			events: queue.iterate(),
@@ -825,6 +815,284 @@ var AcpRuntimeManager = class {
 			}
 		};
 	}
+	async runRuntimeTurnTask(task) {
+		let turn;
+		try {
+			turn = await this.prepareRuntimeTurn(task);
+			const { sessionId, resumed, loadError } = await this.connectRuntimeTurn(task, turn);
+			await this.resolveRuntimeTurnReady(task, turn, resumed, loadError);
+			if (this.cancelRuntimeTurnBeforePrompt(task)) return;
+			await this.applyPendingRuntimeTurnCancel(task, turn);
+			const response = await runPromptTurn({
+				client: turn.client,
+				sessionId,
+				prompt: task.promptInput,
+				timeoutMs: task.input.timeoutMs ?? this.options.timeoutMs,
+				conversation: turn.conversation,
+				promptMessageId: turn.promptMessageId
+			});
+			await this.saveCompletedRuntimeTurn(turn, response.stopReason);
+			task.settleResult({
+				status: response.stopReason === "cancelled" ? "cancelled" : "completed",
+				...response.stopReason ? { stopReason: response.stopReason } : {}
+			});
+		} catch (error) {
+			this.failRuntimeTurn(task, error);
+		} finally {
+			await this.finalizeRuntimeTurn(task, turn);
+		}
+	}
+	async prepareRuntimeTurn(task) {
+		const record = await this.requireRecord(task.input.handle.acpxRecordId ?? task.input.handle.sessionKey);
+		const conversation = cloneSessionConversation(record);
+		let acpxState = cloneSessionAcpxState(record.acpx);
+		const promptStartedAt = isoNow();
+		const promptMessageId = recordPromptSubmission(conversation, task.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 });
+		const client = pendingClient ?? this.createTurnClient(record);
+		const turn = {
+			record,
+			conversation,
+			acpxState,
+			liveCheckpoint: this.createRuntimeTurnCheckpoint(record, conversation, () => turn.acpxState),
+			client,
+			pendingClient,
+			promptMessageId,
+			activeSessionId: record.acpSessionId
+		};
+		task.state.activeController = this.buildRuntimeTurnController(task, turn);
+		this.activeControllers.set(record.acpxRecordId, task.state.activeController);
+		this.installRuntimeTurnEventHandlers(task, turn);
+		return turn;
+	}
+	createTurnClient(record) {
+		return this.createClient({
+			agentCommand: record.agentCommand,
+			cwd: record.cwd,
+			mcpServers: [...this.options.mcpServers ?? []],
+			permissionMode: this.options.permissionMode,
+			nonInteractivePermissions: this.options.nonInteractivePermissions,
+			onPermissionRequest: this.options.onPermissionRequest,
+			verbose: this.options.verbose
+		});
+	}
+	createRuntimeTurnCheckpoint(record, conversation, readAcpxState) {
+		return new LiveSessionCheckpoint({ save: async () => {
+			record.lastUsedAt = isoNow();
+			record.acpx = readAcpxState();
+			applyConversation(record, conversation);
+			await this.refreshClosedState(record);
+			await this.options.sessionStore.save(record);
+		} });
+	}
+	buildRuntimeTurnController(task, turn) {
+		return {
+			hasActivePrompt: () => turn.client.hasActivePrompt(),
+			requestCancelActivePrompt: async () => await this.requestRuntimeTurnCancel(task, turn),
+			setSessionMode: async (modeId) => {
+				await this.waitForRuntimeControlSession(task, turn);
+				await turn.client.setSessionMode(turn.activeSessionId, modeId);
+				const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
+				nextState.desired_mode_id = modeId;
+				turn.acpxState = nextState;
+			},
+			setSessionModel: async (modelId) => {
+				await this.waitForRuntimeControlSession(task, turn);
+				await turn.client.setSessionModel(turn.activeSessionId, modelId);
+			},
+			setSessionConfigOption: async (configId, value) => {
+				return (await task.state.activeController.setResolvedSessionConfigOption(configId, value)).response;
+			},
+			setResolvedSessionConfigOption: async (configId, value) => await this.setRuntimeResolvedSessionConfigOption(task, turn, configId, value)
+		};
+	}
+	async waitForRuntimeControlSession(task, turn) {
+		if (turn.client.hasActivePrompt()) return;
+		await task.sessionReady.promise;
+	}
+	async requestRuntimeTurnCancel(task, turn) {
+		if (turn.client.hasActivePrompt()) return await turn.client.requestCancelActivePrompt();
+		if (!task.state.turnActive) return false;
+		task.state.pendingCancel = true;
+		return true;
+	}
+	async setRuntimeResolvedSessionConfigOption(task, turn, configId, value) {
+		await this.waitForRuntimeControlSession(task, turn);
+		const resolvedConfigId = resolveSupportedConfigOptionId({
+			...turn.record,
+			acpx: turn.acpxState ?? void 0
+		}, configId);
+		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value);
+		this.applyRuntimeConfigOptionState(turn, resolvedConfigId, value, response);
+		return {
+			configId: resolvedConfigId,
+			response
+		};
+	}
+	applyRuntimeConfigOptionState(turn, configId, value, response) {
+		if (response?.configOptions) {
+			const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
+			nextState.config_options = structuredClone(response.configOptions);
+			turn.acpxState = nextState;
+		}
+		if (configId === "mode") {
+			const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
+			nextState.desired_mode_id = value;
+			turn.acpxState = nextState;
+			return;
+		}
+		if (configId !== "model") {
+			const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
+			nextState.desired_config_options = {
+				...nextState.desired_config_options,
+				[configId]: value
+			};
+			turn.acpxState = nextState;
+		}
+	}
+	installRuntimeTurnEventHandlers(task, turn) {
+		turn.client.setEventHandlers({
+			onSessionUpdate: (notification) => {
+				turn.acpxState = recordSessionUpdate(turn.conversation, turn.acpxState, notification);
+				trimConversationForRuntime(turn.conversation);
+				turn.liveCheckpoint.request();
+				this.emitRuntimeTurnEvent(task, {
+					jsonrpc: "2.0",
+					method: "session/update",
+					params: notification
+				});
+			},
+			onClientOperation: (operation) => {
+				turn.acpxState = recordClientOperation(turn.conversation, turn.acpxState, operation);
+				trimConversationForRuntime(turn.conversation);
+				turn.liveCheckpoint.request();
+				this.emitRuntimeTurnEvent(task, {
+					type: "client_operation",
+					...operation
+				});
+			}
+		});
+	}
+	emitRuntimeTurnEvent(task, payload) {
+		const parsed = parsePromptEventLine(JSON.stringify(payload));
+		if (!parsed) return;
+		task.queue.push(parsed);
+	}
+	async connectRuntimeTurn(task, turn) {
+		const loaded = turn.pendingClient ? {
+			sessionId: turn.record.acpSessionId,
+			resumed: false,
+			loadError: void 0
+		} : await this.connectRuntimeTurnClient(task, turn);
+		turn.acpxState = cloneSessionAcpxState(turn.record.acpx);
+		return loaded;
+	}
+	async connectRuntimeTurnClient(task, turn) {
+		return await connectAndLoadSession({
+			client: turn.client,
+			record: turn.record,
+			resumePolicy: resumePolicyForSessionMode(task.input.sessionMode),
+			timeoutMs: this.options.timeoutMs,
+			activeController: task.state.activeController,
+			onClientAvailable: () => this.publishRuntimeTurnController(task, turn),
+			onConnectedRecord: (connectedRecord) => {
+				connectedRecord.lastPromptAt = isoNow();
+			},
+			onSessionIdResolved: (sessionIdValue) => {
+				turn.activeSessionId = sessionIdValue;
+			}
+		});
+	}
+	publishRuntimeTurnController(task, turn) {
+		const controller = task.state.activeController;
+		if (controller) this.activeControllers.set(turn.record.acpxRecordId, controller);
+	}
+	async resolveRuntimeTurnReady(task, turn, resumed, loadError) {
+		task.sessionReady.resolve();
+		turn.record.lastRequestId = task.input.requestId;
+		turn.record.lastPromptAt = isoNow();
+		turn.record.closed = false;
+		turn.record.closedAt = void 0;
+		turn.record.lastUsedAt = isoNow();
+		await turn.liveCheckpoint.checkpoint();
+		this.emitRuntimeTurnLoadStatus(task, resumed, loadError);
+	}
+	emitRuntimeTurnLoadStatus(task, resumed, loadError) {
+		if (!resumed && !loadError) return;
+		this.emitRuntimeTurnEvent(task, {
+			type: "status",
+			text: loadError ? `session reconnect fallback: ${loadError}` : "session resumed"
+		});
+	}
+	cancelRuntimeTurnBeforePrompt(task) {
+		if (!task.state.pendingCancel && !task.input.signal?.aborted) return false;
+		task.state.pendingCancel = false;
+		task.settleResult({
+			status: "cancelled",
+			stopReason: "cancelled"
+		});
+		return true;
+	}
+	async applyPendingRuntimeTurnCancel(task, turn) {
+		if (!task.state.pendingCancel || !turn.client.hasActivePrompt()) return false;
+		const cancelled = await turn.client.requestCancelActivePrompt();
+		if (cancelled) task.state.pendingCancel = false;
+		return cancelled;
+	}
+	async saveCompletedRuntimeTurn(turn, _stopReason) {
+		turn.record.acpSessionId = turn.activeSessionId;
+		reconcileAgentSessionId(turn.record, turn.record.agentSessionId);
+		turn.record.protocolVersion = turn.client.initializeResult?.protocolVersion;
+		turn.record.agentCapabilities = turn.client.initializeResult?.agentCapabilities;
+		turn.record.acpx = turn.acpxState;
+		applyConversation(turn.record, turn.conversation);
+		applyLifecycleSnapshotToRecord(turn.record, turn.client.getAgentLifecycleSnapshot());
+		await this.options.sessionStore.save(turn.record);
+	}
+	failRuntimeTurn(task, error) {
+		task.sessionReady.reject(error);
+		const normalized = normalizeOutputError(error, { origin: "runtime" });
+		task.settleResult({
+			status: "failed",
+			error: {
+				message: normalized.message,
+				...normalized.code ? { code: normalized.code } : {},
+				...normalized.detailCode ? { detailCode: normalized.detailCode } : {},
+				...normalized.retryable !== void 0 ? { retryable: normalized.retryable } : {}
+			}
+		});
+	}
+	async finalizeRuntimeTurn(task, turn) {
+		task.state.turnActive = false;
+		task.input.signal?.removeEventListener("abort", task.abortHandler);
+		turn?.client.clearEventHandlers();
+		if (!(turn ? await this.finalizeRuntimeTurnRecord(turn) : false)) await turn?.client.close().catch(() => {});
+		if (turn) {
+			this.activeControllers.delete(turn.record.acpxRecordId);
+			this.closingActiveRecords.delete(turn.record.acpxRecordId);
+		}
+		task.queue.close();
+	}
+	async finalizeRuntimeTurnRecord(turn) {
+		applyLifecycleSnapshotToRecord(turn.record, turn.client.getAgentLifecycleSnapshot());
+		turn.record.acpx = turn.acpxState;
+		applyConversation(turn.record, turn.conversation);
+		turn.record.lastUsedAt = isoNow();
+		await turn.liveCheckpoint.flush().catch(() => {});
+		const closed = await this.refreshClosedState(turn.record);
+		await this.options.sessionStore.save(turn.record).catch(() => {});
+		if (closed) return false;
+		return await this.retainPersistentClientAfterTurn({
+			record: turn.record,
+			client: turn.client
+		});
+	}
 	async *runTurn(input) {
 		const turn = this.startTurn(input);
 		yield* turn.events;
@@ -837,6 +1105,7 @@ var AcpRuntimeManager = class {
 			acpxRecordId: record.acpxRecordId,
 			backendSessionId: record.acpSessionId,
 			agentSessionId: record.agentSessionId,
+			...buildModelsField(record),
 			details: {
 				cwd: record.cwd,
 				lastUsedAt: record.lastUsedAt,
@@ -859,18 +1128,21 @@ var AcpRuntimeManager = class {
 	async setConfigOption(handle, key, value, sessionMode = "persistent") {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
 		const controller = this.activeControllers.get(record.acpxRecordId);
-		let targetRecord = record;
 		if (controller) {
-			const response = await controller.setSessionConfigOption(key, value);
-			applyConfigOptionsToRecord(targetRecord, response);
-		} else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
-			applyConfigOptionsToRecord(connectedRecord, await client.setSessionConfigOption(sessionId, key, value));
-			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);
+			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value);
+			applyConfigOptionsToRecord(record, response);
+			if (configId === "mode") setDesiredModeId(record, value);
+			else setDesiredConfigOption(record, configId, value);
+			await this.options.sessionStore.save(record);
+			return;
+		}
+		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
+			const configId = resolveSupportedConfigOptionId(connectedRecord, key);
+			applyConfigOptionsToRecord(connectedRecord, await client.setSessionConfigOption(sessionId, configId, value));
+			if (configId === "mode") setDesiredModeId(connectedRecord, value);
+			else setDesiredConfigOption(connectedRecord, configId, value);
+		});
+		await this.options.sessionStore.save(result.record);
 	}
 	async cancel(handle) {
 		await this.activeControllers.get(handle.acpxRecordId ?? handle.sessionKey)?.requestCancelActivePrompt();
@@ -898,6 +1170,7 @@ var AcpRuntimeManager = class {
 			mcpServers: [...this.options.mcpServers ?? []],
 			permissionMode: this.options.permissionMode,
 			nonInteractivePermissions: this.options.nonInteractivePermissions,
+			onPermissionRequest: this.options.onPermissionRequest,
 			verbose: this.options.verbose
 		});
 		try {
@@ -924,6 +1197,7 @@ function safeSessionId(sessionId) {
 	return encodeURIComponent(sessionId);
 }
 var FileSessionStore = class {
+	stateDir;
 	constructor(stateDir) {
 		this.stateDir = stateDir;
 	}
@@ -999,21 +1273,30 @@ function writeHandleState(handle, state) {
 }
 //#endregion
 //#region src/runtime/public/probe.ts
+function isPrimitiveDetail(value) {
+	return value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
+}
+function formatFunctionDetail(value) {
+	return value.name ? `[Function ${value.name}]` : "[Function]";
+}
+function serializeRuntimeDetail(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	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";
+}
 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();
+	if (isPrimitiveDetail(value)) return String(value);
+	if (typeof value === "function") return formatFunctionDetail(value);
 	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";
+		return serializeRuntimeDetail(value);
 	} catch {
 		return "unserializable object";
 	}
@@ -1024,21 +1307,7 @@ function normalizeRuntimeDetails(details) {
 async function probeRuntime(options, deps = {}) {
 	const agentName = options.probeAgent?.trim() || "codex";
 	const agentCommand = options.agentRegistry.resolve(agentName);
-	const client = deps.clientFactory?.({
-		agentCommand,
-		cwd: options.cwd,
-		mcpServers: [...options.mcpServers ?? []],
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		verbose: options.verbose
-	}) ?? new AcpClient({
-		agentCommand,
-		cwd: options.cwd,
-		mcpServers: [...options.mcpServers ?? []],
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		verbose: options.verbose
-	});
+	const client = createProbeClient(options, agentCommand, deps);
 	try {
 		await client.start();
 		return {
@@ -1066,6 +1335,17 @@ async function probeRuntime(options, deps = {}) {
 		await client.close().catch(() => {});
 	}
 }
+function createProbeClient(options, agentCommand, deps) {
+	const clientOptions = {
+		agentCommand,
+		cwd: options.cwd,
+		mcpServers: [...options.mcpServers ?? []],
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		verbose: options.verbose
+	};
+	return deps.clientFactory?.(clientOptions) ?? new AcpClient(clientOptions);
+}
 //#endregion
 //#region src/runtime.ts
 const ACPX_BACKEND_ID = "acpx";
@@ -1085,6 +1365,8 @@ function createAgentRegistry(params) {
 	};
 }
 var AcpxRuntime = class {
+	options;
+	testOptions;
 	healthy = false;
 	manager = null;
 	managerPromise = null;
@@ -1119,7 +1401,8 @@ var AcpxRuntime = class {
 			agent,
 			mode: input.mode,
 			cwd: input.cwd ?? this.options.cwd,
-			resumeSessionId: input.resumeSessionId
+			resumeSessionId: input.resumeSessionId,
+			sessionOptions: input.sessionOptions
 		});
 		const handle = {
 			sessionKey: input.sessionKey,