acpx 0.17.0 → 0.18.0

package/dist/runtime.js

@@ -1,7 +1,7 @@
-import { C as textPrompt, D as findSession, F as resolveSessionRecord, L as assertPersistedKeyPolicy, P as readSessionRecord, R as parseSessionRecord, gt as extractAcpError, mt as writePrivateJsonFile, t as tryCancelOnRunningOwner, vt as isAcpResourceNotFoundError, z as serializeSessionRecordForDisk } from "./ipc-D3akHMEq.js";
-import { A as setDesiredModeId, B as recordClientOperation, C as withConnectedSession, D as applyInitialModelSelection, E as applyConfigOptionsToRecord, F as createInitialSessionRecord, G as AcpClient, H as recordSessionUpdate, I as reconcileAgentSessionId, J as RequestedModelUnsupportedError, K as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, L as cloneSessionAcpxState, M as sessionOptionsFromRecord, N as applyConversation, O as applyModelSelection, P as applyLifecycleSnapshotToRecord, R as cloneSessionConversation, T as applyConfigOptionSelection, U as trimConversationForRuntime, V as recordPromptSubmission, W as advertisedModelState, Y as isRequestedModelUnsupportedError, _ as cancelSessionPrompt, c as LiveSessionCheckpoint, ct as normalizeOutputError, h as ensureSession, it as assertControlAuthority, j as persistSessionOptions, k as applyRequestedModelIfAdvertised, l as runPromptTurn, ot as withTimeout, q as REQUESTED_MODEL_UNSUPPORTED_REASONS, r as sendSession, s as DISCARD_OUTPUT_FORMATTER, v as closeSession, w as connectAndLoadSession } from "./queue-owner-runtime--IbbndGz.js";
-import { D as normalizeAgentCommandInput, a as createAgentRegistry, i as DEFAULT_AGENT_NAME } from "./agent-registry-DU6mhZBL.js";
-import { t as watchSession } from "./watch-BbBxO-kb.js";
+import { B as serializeSessionRecordForDisk, F as readSessionRecord, I as resolveSessionRecord, O as findSession, R as assertPersistedKeyPolicy, bt as isAcpResourceNotFoundError, ht as writePrivateJsonFile, t as tryCancelOnRunningOwner, vt as extractAcpError, w as textPrompt, z as parseSessionRecord } from "./ipc-BJrvfNXr.js";
+import { A as applyInitialModelSelection, B as cloneSessionAcpxState, C as setSessionModeOnOwner, D as connectAndLoadSession, E as withConnectedSession, F as sessionOptionsFromRecord, G as recordSessionUpdate, I as applyConversation, J as AcpClient, K as trimConversationForRuntime, L as applyLifecycleSnapshotToRecord, M as applyRequestedModelIfAdvertised, N as setDesiredModeId, O as applyConfigOptionSelection, P as persistSessionOptions, Q as isRequestedModelUnsupportedError, R as createInitialSessionRecord, T as setSessionModelOnOwner, U as recordClientOperation, V as cloneSessionConversation, W as recordPromptSubmission, X as REQUESTED_MODEL_UNSUPPORTED_REASONS, Y as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, Z as RequestedModelUnsupportedError, _ as cancelSessionPrompt, c as LiveSessionCheckpoint, dt as normalizeOutputError, h as ensureSession, j as applyModelSelection, k as applyConfigOptionsToRecord, l as runPromptTurn, lt as withTimeout, ot as TimeoutError, q as advertisedModelState, r as sendSession, s as DISCARD_OUTPUT_FORMATTER, st as assertControlAuthority, v as closeSession, x as setSessionConfigOptionOnOwner, z as reconcileAgentSessionId } from "./queue-owner-runtime-Cr0dWJuL.js";
+import { D as normalizeAgentCommandInput, a as createAgentRegistry, i as DEFAULT_AGENT_NAME } from "./agent-registry-DdKB-zia.js";
+import { t as watchSession } from "./watch-Dp73ph8h.js";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -22,6 +22,38 @@ function isAcpRuntimeError(value) {
 	return value instanceof AcpRuntimeError;
 }
 //#endregion
+//#region src/runtime/engine/controls.ts
+/** Controls acpx implements for every backend it exposes. */
+const ACPX_CAPABILITIES = { controls: [
+	"session/set_mode",
+	"session/set_model",
+	"session/set_config_option",
+	"session/status"
+] };
+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));
+}
+/** Reports the config option keys the session last advertised, if any. */
+function capabilitiesFromRecord(record) {
+	const advertisedIds = advertisedConfigOptionIds(record);
+	if (!advertisedIds || advertisedIds.size === 0) return ACPX_CAPABILITIES;
+	return {
+		...ACPX_CAPABILITIES,
+		configOptionKeys: [...advertisedIds]
+	};
+}
+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}.`);
+}
+//#endregion
 //#region src/runtime/public/shared.ts
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -547,6 +579,61 @@ function updateStatusEvent(payload, tag) {
 }
 //#endregion
 //#region src/runtime/public/probe.ts
+/**
+* Inspect session model metadata without a runtime store or prompt. The agent
+* may create native session history; only its owned transport is closed.
+*/
+async function inspectAgentModels(options) {
+	options.signal?.throwIfAborted();
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) throw new RangeError("Model inspection timeoutMs must be positive and at most 2147483647");
+	const deadline = new AbortController();
+	const signal = options.signal ? AbortSignal.any([options.signal, deadline.signal]) : deadline.signal;
+	const assertActive = () => signal.throwIfAborted();
+	const client = new AcpClient({
+		...normalizeAgentCommandInput(options.agentCommand),
+		cwd: options.cwd,
+		agentProcessEnv: options.agentProcessEnv,
+		permissionMode: "deny-all",
+		nonInteractivePermissions: "deny",
+		fs: false,
+		terminal: false,
+		processLifecycle: {
+			onBeforeSpawn: assertActive,
+			onSpawned: assertActive
+		}
+	});
+	const timer = setTimeout(() => deadline.abort(new TimeoutError(timeoutMs)), timeoutMs);
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	const inspection = (async () => {
+		assertActive();
+		await client.start();
+		assertActive();
+		const { models } = await client.createSession();
+		assertActive();
+		return models ? {
+			currentModelId: models.currentModelId,
+			availableModelIds: models.availableModels.map((model) => model.modelId),
+			availableModels: models.availableModels
+		} : void 0;
+	})();
+	try {
+		return await Promise.race([inspection, aborted]);
+	} finally {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+		try {
+			if (signal.aborted) await client.close();
+		} finally {
+			await inspection.catch(() => {});
+			await client.close();
+		}
+	}
+}
 function isPrimitiveDetail(value) {
 	return value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
 }
@@ -863,19 +950,13 @@ function createRecordId(sessionKey, mode) {
 function resumePolicyForSessionMode(mode) {
 	return mode === "persistent" ? "same-session-only" : "allow-new";
 }
-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 startRuntimeClient(client, agent, timeoutMs) {
+	try {
+		await withTimeout(client.start(), timeoutMs);
+	} catch (error) {
+		if (!(error instanceof TimeoutError)) throw error;
+		throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACP agent ${path.basename(agent.agentArgv?.[0] ?? agent.agentCommand.split(/\s+/)[0])} did not complete ACP initialization within ${timeoutMs}ms. Check that the configured command starts an ACP server.`, { cause: error });
+	}
 }
 async function createOrLoadRuntimeSession(client, resumeSessionId, cwd) {
 	if (resumeSessionId) {
@@ -906,6 +987,7 @@ var AcpRuntimeManager = class {
 	options;
 	deps;
 	activeControllers = /* @__PURE__ */ new Map();
+	controlSessionRecords = /* @__PURE__ */ new Map();
 	retainedSessionOwners = /* @__PURE__ */ new Map();
 	retiringSessionOwners = /* @__PURE__ */ new Set();
 	pendingOneShotRecordIds = /* @__PURE__ */ new Map();
@@ -1022,6 +1104,7 @@ var AcpRuntimeManager = class {
 	createSessionOwner(input) {
 		const owner = {
 			...input,
+			checkpoint: new LiveSessionCheckpoint({ save: async () => this.saveSessionOwner(owner) }),
 			bufferSessionUpdates: false,
 			pendingSessionUpdates: []
 		};
@@ -1031,13 +1114,26 @@ var AcpRuntimeManager = class {
 		});
 		return owner;
 	}
+	async saveSessionOwner(owner) {
+		if (!owner.recordId) return;
+		const active = owner.activeTurn?.turn;
+		const target = active ?? owner.projection;
+		if (!target) return;
+		const { record, conversation } = target;
+		if (active?.connected) record.acpx = active.acpxState;
+		record.lastUsedAt = isoNow();
+		applyConversation(record, conversation);
+		applyLifecycleSnapshotToRecord(record, owner.client.getAgentLifecycleSnapshot());
+		await this.refreshClosedState(record);
+		await this.options.sessionStore.save(record);
+	}
 	routeOwnedSessionUpdate(owner, notification) {
 		const active = owner.activeTurn;
 		if (active) {
 			const { task, turn } = active;
 			if (turn.connected) {
 				turn.acpxState = recordSessionUpdate(turn.conversation, turn.acpxState, notification);
-				turn.liveCheckpoint.request();
+				owner.checkpoint.request();
 			} else turn.record.acpx = recordSessionUpdate(turn.conversation, turn.record.acpx, notification);
 			trimConversationForRuntime(turn.conversation);
 			this.emitRuntimeTurnEvent(task, {
@@ -1058,7 +1154,7 @@ var AcpRuntimeManager = class {
 		}
 		projection.record.acpx = recordSessionUpdate(projection.conversation, projection.record.acpx, notification);
 		trimConversationForRuntime(projection.conversation);
-		projection.checkpoint.request();
+		owner.checkpoint.request();
 	}
 	routeOwnedClientOperation(owner, operation) {
 		const active = owner.activeTurn;
@@ -1066,7 +1162,7 @@ var AcpRuntimeManager = class {
 		const { task, turn } = active;
 		if (turn.connected) {
 			turn.acpxState = recordClientOperation(turn.conversation, turn.acpxState, operation);
-			turn.liveCheckpoint.request();
+			owner.checkpoint.request();
 		} else turn.record.acpx = recordClientOperation(turn.conversation, turn.record.acpx, operation);
 		trimConversationForRuntime(turn.conversation);
 		this.emitRuntimeTurnEvent(task, {
@@ -1078,15 +1174,7 @@ var AcpRuntimeManager = class {
 		record.acpx = acpxState;
 		owner.projection = {
 			record,
-			conversation,
-			checkpoint: new LiveSessionCheckpoint({ save: async () => {
-				if (!owner.recordId) return;
-				record.lastUsedAt = isoNow();
-				applyConversation(record, conversation);
-				applyLifecycleSnapshotToRecord(record, owner.client.getAgentLifecycleSnapshot());
-				await this.refreshClosedState(record);
-				await this.options.sessionStore.save(record);
-			} })
+			conversation
 		};
 		owner.activeTurn = void 0;
 		this.drainPendingSessionUpdates(owner);
@@ -1096,7 +1184,7 @@ var AcpRuntimeManager = class {
 	}
 	async flushSessionOwner(owner) {
 		await owner.client.waitForSessionUpdatesIdle?.().catch(() => {});
-		await owner.projection?.checkpoint.flush();
+		await owner.checkpoint.flush();
 	}
 	removeRetainedSessionOwner(owner) {
 		if (owner.recordId && this.retainedSessionOwners.get(owner.recordId) === owner) this.retainedSessionOwners.delete(owner.recordId);
@@ -1127,7 +1215,7 @@ var AcpRuntimeManager = class {
 		await this.closeClient(owner.client).catch(() => {
 			this.retiringSessionOwners.add(owner);
 		});
-		await owner.projection?.checkpoint.flush().catch(() => {});
+		await owner.checkpoint.flush().catch(() => {});
 		try {
 			owner.client.clearEventHandlers();
 		} catch {}
@@ -1150,19 +1238,15 @@ var AcpRuntimeManager = class {
 		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 = {
+		if (latest?.acpx?.reset_on_next_ensure === true) record.acpx = {
 			...record.acpx,
-			...latest.acpx
+			reset_on_next_ensure: true
 		};
 		return true;
 	}
 	async retainPersistentSessionOwnerAfterTurn(input) {
-		const { record, owner, conversation, acpxState } = input;
-		if (!this.canRetainPersistentSessionOwner(owner, record)) {
-			owner.activeTurn = void 0;
-			return false;
-		}
-		this.attachIdleProjection(owner, record, conversation, acpxState);
+		const { record, owner } = input;
+		if (!this.canRetainPersistentSessionOwner(owner, record)) return false;
 		const previousOwner = this.retainedSessionOwners.get(record.acpxRecordId);
 		this.retainedSessionOwners.set(record.acpxRecordId, owner);
 		if (previousOwner && previousOwner !== owner) {
@@ -1184,6 +1268,21 @@ var AcpRuntimeManager = class {
 			agentArgv: agentArgv ? [...agentArgv] : void 0
 		}) : servers ?? []];
 	}
+	resolveSessionPermissions(session) {
+		const { sessionKey, cwd, agentCommand, agentArgv } = session;
+		const { permissionMode = this.options.permissionMode, nonInteractivePermissions = this.options.nonInteractivePermissions, permissionPolicy = this.options.permissionPolicy, onPermissionRequest = this.options.onPermissionRequest } = this.options.sessionPermissions?.({
+			sessionKey,
+			cwd,
+			agentCommand,
+			agentArgv: agentArgv ? [...agentArgv] : void 0
+		}) ?? {};
+		return {
+			permissionMode,
+			nonInteractivePermissions,
+			permissionPolicy,
+			onPermissionRequest
+		};
+	}
 	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption, authority) {
 		await this.retrySessionCleanup(record.acpxRecordId);
 		assertControlAuthority(authority);
@@ -1198,20 +1297,27 @@ var AcpRuntimeManager = class {
 					record: ownedRecord
 				});
 				this.refreshOwnedRecordLifecycle(owner, ownedRecord);
-				return {
-					value,
-					record: ownedRecord
-				};
+				await owner.checkpoint.checkpoint();
+				return value;
 			} finally {
 				await this.flushSessionOwner(owner);
 			}
 		}
 		let controlClient;
+		let controlledRecord = record;
+		const checkpoint = new LiveSessionCheckpoint({ save: async () => this.options.sessionStore.save(controlledRecord) });
 		try {
-			const result = await withConnectedSession({
+			const result = await settleAttempt(async () => withConnectedSession({
 				sessionRecordId: record.acpxRecordId,
-				loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
-				saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
+				loadRecord: async (sessionRecordId) => {
+					controlledRecord = await this.requireRecord(sessionRecordId);
+					this.controlSessionRecords.set(sessionRecordId, {
+						record: controlledRecord,
+						checkpoint
+					});
+					return controlledRecord;
+				},
+				saveRecord: async () => checkpoint.checkpoint(),
 				createClient: (options) => controlClient = this.createClient({
 					...options,
 					processLifecycle: this.options.processLifecycle,
@@ -1224,10 +1330,10 @@ var AcpRuntimeManager = class {
 					...record,
 					sessionKey: record.name ?? record.acpxRecordId
 				}),
-				permissionMode: this.options.permissionMode,
-				nonInteractivePermissions: this.options.nonInteractivePermissions,
-				permissionPolicy: this.options.permissionPolicy,
-				onPermissionRequest: this.options.onPermissionRequest,
+				...this.resolveSessionPermissions({
+					...record,
+					sessionKey: record.name ?? record.acpxRecordId
+				}),
 				elicitationModes: this.options.elicitationModes,
 				verbose: this.options.verbose,
 				timeoutMs: this.options.timeoutMs,
@@ -1235,12 +1341,14 @@ var AcpRuntimeManager = class {
 				replacingConfigOption,
 				authority,
 				run
-			});
-			return {
-				value: result.value,
-				record: result.record
-			};
+			}));
+			this.controlSessionRecords.delete(record.acpxRecordId);
+			const flushed = await settleAttempt(async () => checkpoint.flush());
+			if (!result.ok) throw result.error;
+			if (!flushed.ok) throw flushed.error;
+			return result.value.value;
 		} finally {
+			this.controlSessionRecords.delete(record.acpxRecordId);
 			if (controlClient) this.liveClients.delete(controlClient);
 		}
 	}
@@ -1262,6 +1370,13 @@ var AcpRuntimeManager = class {
 	async withManagerLock(locks, key, run, authority) {
 		this.assertOpen();
 		assertControlAuthority(authority);
+		return await this.serializeManagerOperation(locks, key, async () => {
+			this.assertOpen();
+			assertControlAuthority(authority);
+			return await run();
+		});
+	}
+	async serializeManagerOperation(locks, key, run) {
 		const previous = locks.get(key) ?? Promise.resolve();
 		let release;
 		const gate = new Promise((resolve) => {
@@ -1271,8 +1386,6 @@ var AcpRuntimeManager = class {
 		locks.set(key, tail);
 		await previous;
 		try {
-			this.assertOpen();
-			assertControlAuthority(authority);
 			return await run();
 		} finally {
 			release();
@@ -1287,8 +1400,26 @@ var AcpRuntimeManager = class {
 			agentCommand,
 			agentArgv
 		};
+		if (input.mode !== "persistent") return await this.acquireRuntimeSession(input, agent);
+		const compatible = await this.reuseCompatiblePersistentSession(input, agent);
+		if (compatible) return compatible;
+		this.assertRuntimeSessionIdle(input.sessionKey);
+		return await this.withManagerLock(this.runtimeOperationLocks, input.sessionKey, async () => this.acquireRuntimeSession(input, agent));
+	}
+	async reuseCompatiblePersistentSession(input, agent) {
+		const controlled = this.controlSessionRecords.get(input.sessionKey);
+		const record = controlled ? controlled.record : await this.findSession(input.sessionKey);
+		if (!record || this.closingActiveRecords.has(input.sessionKey) || !shouldReuseExistingRecord(record, {
+			...agent,
+			resumeSessionId: input.resumeSessionId
+		})) return;
+		if (!record.closed) return record;
+		if (!controlled || this.sessionTasks.has(input.sessionKey)) return;
+		return await this.reuseRuntimeSession({ record }, controlled.checkpoint);
+	}
+	async acquireRuntimeSession(input, agent) {
 		const existing = await this.loadExistingRuntimeSession(input);
-		if (existing && this.canReuseRuntimeSession(input, agent, existing)) return await this.reuseRuntimeSession(existing.record);
+		if (existing && this.canReuseRuntimeSession(input, agent, existing)) return await this.reuseRuntimeSession(existing);
 		await this.closeConflictingPersistentSession(input, existing?.owner);
 		return await this.createOwnedRuntimeSession(input, agent);
 	}
@@ -1319,17 +1450,26 @@ var AcpRuntimeManager = class {
 			resumeSessionId: input.resumeSessionId
 		})) return false;
 		if (input.mode === "persistent") return true;
-		return Boolean(existing.owner && isDeepStrictEqual(sessionOptionsFromRecord(existing.record), input.sessionOptions));
+		return Boolean(existing.owner && !existing.record.closed && this.pendingOneShotRecordIds.get(input.sessionKey) === existing.record.acpxRecordId && this.retainedSessionOwners.get(existing.record.acpxRecordId) === existing.owner && isDeepStrictEqual(sessionOptionsFromRecord(existing.record), input.sessionOptions));
+	}
+	assertRuntimeSessionIdle(recordId) {
+		if (this.sessionTasks.has(recordId) || this.runtimeOperationLocks.has(recordId)) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `Cannot ensure session ${recordId} with incompatible or closing state while its work is unfinished. Wait for existing work to finish or use a different session key.`);
 	}
-	async reuseRuntimeSession(record) {
+	async reuseRuntimeSession({ record, owner }, checkpoint = owner?.checkpoint) {
+		if (!record.closed && !this.closingActiveRecords.has(record.acpxRecordId)) return record;
 		record.closed = false;
 		record.closedAt = void 0;
 		this.closingActiveRecords.delete(record.acpxRecordId);
-		await this.options.sessionStore.save(record);
+		if (checkpoint) await checkpoint.checkpoint();
+		else await this.options.sessionStore.save(record);
 		return record;
 	}
 	async closeConflictingPersistentSession(input, owner) {
-		if (input.mode === "persistent" && owner?.recordId) await this.closeRetainedSessionOwner(owner.recordId);
+		if (input.mode === "persistent" && owner?.recordId) {
+			this.removeRetainedSessionOwner(owner);
+			this.retiringSessionOwners.add(owner);
+			await this.retrySessionCleanup(owner.recordId);
+		}
 	}
 	async createOwnedRuntimeSession(input, agent) {
 		const { cwd, agentCommand, agentArgv } = agent;
@@ -1341,10 +1481,10 @@ var AcpRuntimeManager = class {
 				...agent,
 				sessionKey: input.sessionKey
 			}),
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
+			...this.resolveSessionPermissions({
+				...agent,
+				sessionKey: input.sessionKey
+			}),
 			elicitationModes: this.options.elicitationModes,
 			processLifecycle: this.options.processLifecycle,
 			processLaunchScope: {
@@ -1361,7 +1501,7 @@ var AcpRuntimeManager = class {
 		});
 		let retained = false;
 		try {
-			await client.start();
+			await startRuntimeClient(client, agent, this.options.timeoutMs);
 			this.assertOpen();
 			const session = await createOrLoadRuntimeSession(client, input.resumeSessionId, cwd);
 			const record = await this.prepareInitialRuntimeRecord({
@@ -1415,7 +1555,7 @@ var AcpRuntimeManager = class {
 	}
 	async retainInitializedSessionOwner(owner, record) {
 		owner.recordId = record.acpxRecordId;
-		await owner.projection?.checkpoint.checkpoint();
+		await owner.checkpoint.checkpoint();
 		this.assertOpen();
 		const previousOwner = this.retainedSessionOwners.get(record.acpxRecordId);
 		this.retainedSessionOwners.set(record.acpxRecordId, owner);
@@ -1465,7 +1605,7 @@ var AcpRuntimeManager = class {
 			return true;
 		};
 		const abortHandler = () => {
-			requestCancel();
+			requestCancel().catch(() => {});
 		};
 		if (input.signal && !input.signal.aborted) input.signal.addEventListener("abort", abortHandler, { once: true });
 		this.queueSessionTask(input.handle.acpxRecordId ?? input.handle.sessionKey, async () => this.runRuntimeTurnTask({
@@ -1493,7 +1633,9 @@ var AcpRuntimeManager = class {
 	}
 	async closeRetainedOneShotHandle(handle) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		if (this.retainedSessionOwners.get(recordId)?.mode === "oneshot") await this.closeRetainedSessionOwner(recordId);
+		await this.serializeManagerOperation(this.runtimeOperationLocks, recordId, async () => {
+			if (this.retainedSessionOwners.get(recordId)?.mode === "oneshot") await this.closeRetainedSessionOwner(recordId);
+		});
 	}
 	async runRuntimeTurnTask(task) {
 		let turn;
@@ -1515,9 +1657,8 @@ var AcpRuntimeManager = class {
 					stopReason: "cancelled"
 				};
 				else {
-					await this.applyPendingRuntimeTurnCancel(task, turn);
 					const response = await this.runRuntimePrompt(task, turn, sessionId);
-					await this.saveCompletedRuntimeTurn(turn);
+					this.updateCompletedRuntimeTurn(turn);
 					terminalResult = {
 						status: response.stopReason === "cancelled" ? "cancelled" : "completed",
 						...response.stopReason ? { stopReason: response.stopReason } : {},
@@ -1526,9 +1667,9 @@ var AcpRuntimeManager = class {
 				}
 			}
 		} catch (error) {
-			terminalResult = this.failRuntimeTurn(task, error);
+			terminalResult = this.handleRuntimeTurnFailure(task, error);
 		}
-		const finalization = await settleAttempt(async () => this.finalizeRuntimeTurn(task, turn));
+		const finalization = await settleAttempt(async () => this.serializeManagerOperation(this.runtimeOperationLocks, task.input.handle.acpxRecordId ?? task.input.handle.sessionKey, async () => this.finalizeRuntimeTurn(task, turn)));
 		if (!finalization.ok) {
 			task.settleResult(this.failRuntimeTurn(task, finalization.error));
 			throw finalization.error;
@@ -1536,21 +1677,18 @@ var AcpRuntimeManager = class {
 		task.settleResult(terminalResult);
 	}
 	async runRuntimePrompt(task, turn, sessionId) {
-		try {
-			return await runPromptTurn({
-				client: turn.client,
-				sessionId,
-				prompt: task.promptInput,
-				timeoutMs: task.input.timeoutMs ?? this.options.timeoutMs,
-				conversation: turn.conversation,
-				promptMessageId: turn.promptMessageId,
-				onPromptRequestWritten: () => task.promptStarted.resolve(),
-				onElicitation: task.input.onElicitation,
-				onPermissionRequest: task.input.onPermissionRequest
-			});
-		} finally {
-			turn.client.endPromptElicitation?.(sessionId);
-		}
+		return await runPromptTurn({
+			client: turn.client,
+			sessionId,
+			prompt: task.promptInput,
+			timeoutMs: task.input.timeoutMs ?? this.options.timeoutMs,
+			conversation: turn.conversation,
+			promptMessageId: turn.promptMessageId,
+			onPromptRequestWritten: () => task.promptStarted.resolve(),
+			onElicitation: task.input.onElicitation,
+			onPermissionRequest: task.input.onPermissionRequest,
+			authority: task.input
+		});
 	}
 	async prepareRuntimeTurn(task) {
 		const recordId = task.input.handle.acpxRecordId ?? task.input.handle.sessionKey;
@@ -1610,13 +1748,19 @@ var AcpRuntimeManager = class {
 		let record = await this.requireRecord(recordId);
 		const retainedOwner = await this.readRetainedSessionOwner(record, { consume: false });
 		if (!retainedOwner) return { record };
-		const projection = retainedOwner.projection;
-		if (projection) record = structuredClone(projection.record);
 		retainedOwner.bufferSessionUpdates = true;
-		return {
-			record,
-			retainedOwner
-		};
+		try {
+			await retainedOwner.checkpoint.flush();
+			const projection = retainedOwner.projection;
+			if (projection) record = structuredClone(projection.record);
+			return {
+				record,
+				retainedOwner
+			};
+		} catch (error) {
+			this.restoreBufferedSessionOwner(retainedOwner);
+			throw error;
+		}
 	}
 	restoreBufferedSessionOwner(owner) {
 		if (!owner) return;
@@ -1632,18 +1776,16 @@ var AcpRuntimeManager = class {
 	}
 	createRunningRuntimeTurn(input) {
 		const { record, conversation, acpxState, client, owner, connected, promptMessageId } = input;
-		const turn = {
+		return {
 			record,
 			conversation,
 			acpxState,
-			liveCheckpoint: this.createRuntimeTurnCheckpoint(record, conversation, () => turn.acpxState),
 			client,
 			owner,
 			connected,
 			promptMessageId,
 			activeSessionId: record.acpSessionId
 		};
-		return turn;
 	}
 	activateRuntimeTurn(task, turn) {
 		const { owner, record } = turn;
@@ -1668,10 +1810,10 @@ var AcpRuntimeManager = class {
 				...record,
 				sessionKey: record.name ?? record.acpxRecordId
 			}),
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
+			...this.resolveSessionPermissions({
+				...record,
+				sessionKey: record.name ?? record.acpxRecordId
+			}),
 			elicitationModes: this.options.elicitationModes,
 			processLifecycle: this.options.processLifecycle,
 			processLaunchScope: {
@@ -1682,15 +1824,6 @@ var AcpRuntimeManager = class {
 			sessionOptions: sessionOptionsFromRecord(record)
 		});
 	}
-	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(),
@@ -1701,12 +1834,14 @@ var AcpRuntimeManager = class {
 				const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
 				nextState.desired_mode_id = modeId;
 				turn.acpxState = nextState;
+				await turn.owner.checkpoint.checkpoint();
 			},
 			setSessionModel: async (modelId, authority) => {
 				await this.waitForRuntimeControlSession(task, turn);
 				const models = advertisedModelState(turn.acpxState);
 				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models, authority);
 				turn.acpxState = applyModelSelection(turn.acpxState, modelId, response);
+				await turn.owner.checkpoint.checkpoint();
 				return response;
 			},
 			setSessionConfigOption: async (configId, value, authority) => {
@@ -1731,9 +1866,10 @@ var AcpRuntimeManager = class {
 			...turn.record,
 			acpx: turn.acpxState ?? void 0
 		}, configId);
-		const modelConfigId = advertisedModelState(turn.acpxState)?.configId;
-		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value, authority);
-		turn.acpxState = applyConfigOptionSelection(turn.acpxState, resolvedConfigId, value, response, modelConfigId);
+		const models = advertisedModelState(turn.acpxState);
+		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value, models, authority);
+		turn.acpxState = applyConfigOptionSelection(turn.acpxState, resolvedConfigId, value, response, models?.configId);
+		await turn.owner.checkpoint.checkpoint();
 		return {
 			configId: resolvedConfigId,
 			response
@@ -1782,7 +1918,7 @@ var AcpRuntimeManager = class {
 		turn.record.closed = false;
 		turn.record.closedAt = void 0;
 		turn.record.lastUsedAt = isoNow();
-		await turn.liveCheckpoint.checkpoint();
+		await turn.owner.checkpoint.checkpoint();
 	}
 	cancelRuntimeTurnBeforePrompt(task) {
 		if (!task.state.pendingCancel && !task.input.signal?.aborted) return false;
@@ -1790,21 +1926,20 @@ var AcpRuntimeManager = class {
 		task.promptStarted.reject(/* @__PURE__ */ new Error("ACP turn cancelled before prompt submission."));
 		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) {
+	updateCompletedRuntimeTurn(turn) {
 		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);
+	}
+	handleRuntimeTurnFailure(task, error) {
+		if (!task.input.signal?.aborted || error !== task.input.signal.reason) return this.failRuntimeTurn(task, error);
+		task.promptStarted.reject(error);
+		task.sessionReady.reject(error);
+		return {
+			status: "cancelled",
+			stopReason: "cancelled"
+		};
 	}
 	failRuntimeTurn(task, error) {
 		task.promptStarted.reject(error);
@@ -1838,13 +1973,24 @@ var AcpRuntimeManager = class {
 	discardRetainedRuntimeTurnOwner(turn) {
 		if (turn) {
 			this.removeRetainedSessionOwner(turn.owner);
-			turn.owner.activeTurn = void 0;
+			this.attachFinalRuntimeProjection(turn);
 		}
 	}
+	attachFinalRuntimeProjection(turn) {
+		const current = turn.connected ? turn.acpxState : turn.record.acpx;
+		const state = turn.record.acpx?.reset_on_next_ensure === true ? {
+			...current,
+			reset_on_next_ensure: true
+		} : current;
+		this.attachIdleProjection(turn.owner, turn.record, turn.conversation, state);
+	}
 	async closeRuntimeTurnClient(turn, pooled) {
 		if (!turn || pooled) return;
-		turn.owner.activeTurn = void 0;
-		const failure = firstFailedAttempt([await settleAttempt(() => turn.client.clearEventHandlers()), await settleAttempt(async () => this.closeClient(turn.client))]);
+		const failure = firstFailedAttempt([
+			await settleAttempt(() => turn.client.clearEventHandlers()),
+			await settleAttempt(async () => this.closeClient(turn.client)),
+			await settleAttempt(async () => this.flushSessionOwner(turn.owner))
+		]);
 		if (failure) {
 			this.retiringSessionOwners.add(turn.owner);
 			throw failure.error;
@@ -1859,19 +2005,12 @@ var AcpRuntimeManager = class {
 	}
 	async finalizeRuntimeTurnRecord(turn) {
 		if (!turn.connected) turn.acpxState = cloneSessionAcpxState(turn.record.acpx);
-		applyLifecycleSnapshotToRecord(turn.record, turn.client.getAgentLifecycleSnapshot());
-		turn.record.acpx = turn.acpxState;
-		applyConversation(turn.record, turn.conversation);
-		turn.record.lastUsedAt = isoNow();
-		await turn.liveCheckpoint.flush();
-		const closed = await this.refreshClosedState(turn.record);
-		await this.options.sessionStore.save(turn.record);
-		if (closed || !turn.connected) return false;
+		await turn.owner.checkpoint.checkpoint();
+		this.attachFinalRuntimeProjection(turn);
+		if (turn.record.closed || !turn.connected) return false;
 		return await this.retainPersistentSessionOwnerAfterTurn({
 			record: turn.record,
-			owner: turn.owner,
-			conversation: turn.conversation,
-			acpxState: turn.acpxState
+			owner: turn.owner
 		});
 	}
 	async *runTurn(input) {
@@ -1897,13 +2036,14 @@ var AcpRuntimeManager = class {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
 		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
-		let targetRecord = record;
-		if (controller) await controller.setSessionMode(mode, authority);
-		else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId }) => {
+		if (controller) {
+			await controller.setSessionMode(mode, authority);
+			return;
+		}
+		await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
 			await client.setSessionMode(sessionId, mode, authority);
-		}, void 0, authority)).record;
-		setDesiredModeId(targetRecord, mode);
-		await this.options.sessionStore.save(targetRecord);
+			setDesiredModeId(connectedRecord, mode);
+		}, void 0, authority);
 	}
 	async setModel(handle, model, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
@@ -1914,16 +2054,13 @@ var AcpRuntimeManager = class {
 		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
-			const response = await controller.setSessionModel(model, authority);
-			record.acpx = applyModelSelection(record.acpx, model, response);
-			await this.options.sessionStore.save(record);
+			await controller.setSessionModel(model, authority);
 			return;
 		}
-		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
+		await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
 			const response = await client.setSessionModel(sessionId, model, advertisedModelState(connectedRecord.acpx), authority);
 			connectedRecord.acpx = applyModelSelection(connectedRecord.acpx, model, response);
 		}, { key: "model" }, authority);
-		await this.options.sessionStore.save(result.record);
 	}
 	async setConfigOption(handle, key, value, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
@@ -1934,23 +2071,19 @@ var AcpRuntimeManager = class {
 		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
-			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value, authority);
-			record.acpx = applyConfigOptionSelection(record.acpx, configId, value, response);
-			await this.options.sessionStore.save(record);
+			const { response } = await controller.setResolvedSessionConfigOption(key, value, authority);
 			return response;
 		}
-		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
+		return await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
 			const configId = resolveSupportedConfigOptionId(connectedRecord, key);
-			const modelConfigId = advertisedModelState(connectedRecord.acpx)?.configId;
-			const response = await client.setSessionConfigOption(sessionId, configId, value, authority);
-			connectedRecord.acpx = applyConfigOptionSelection(connectedRecord.acpx, configId, value, response, modelConfigId);
+			const models = advertisedModelState(connectedRecord.acpx);
+			const response = await client.setSessionConfigOption(sessionId, configId, value, models, authority);
+			connectedRecord.acpx = applyConfigOptionSelection(connectedRecord.acpx, configId, value, response, models?.configId);
 			return response;
 		}, {
 			key,
 			resolve: (connectedRecord) => resolveSupportedConfigOptionId(connectedRecord, key)
 		}, authority);
-		await this.options.sessionStore.save(result.record);
-		return result.value;
 	}
 	async cancel(handle) {
 		await this.activeControllers.get(handle.acpxRecordId ?? handle.sessionKey)?.requestCancelActivePrompt();
@@ -2023,7 +2156,8 @@ var AcpRuntimeManager = class {
 				if (connection.owner) await this.flushSessionOwner(connection.owner);
 			}),
 			await settleAttempt(() => connection.owner?.client.clearEventHandlers()),
-			await settleAttempt(async () => this.closeClient(connection.client))
+			await settleAttempt(async () => this.closeClient(connection.client)),
+			await settleAttempt(async () => connection.owner?.checkpoint.flush())
 		]);
 		if (failure) throw failure.error;
 	}
@@ -2158,6 +2292,16 @@ function sharedRecordId(handle) {
 	if (handle.backend !== SHARED_BACKEND || !handle.acpxRecordId) return invalidOption("A shared runtime requires a handle from a shared session.");
 	return handle.acpxRecordId;
 }
+/**
+* Shared controls are owner-only. Falling back to a direct connection would
+* start a second adapter connection for a session another process owns, and
+* that path may create a fresh provider session when the saved one no longer
+* loads. Shared turns already refuse that trade; controls refuse it too.
+*/
+function requireOwnerDispatch(result, control) {
+	if (result === void 0) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", `No running owner holds this shared session, so ${control} was not sent. Submit a turn to start an owner, or apply the change with the equivalent acpx command, which connects directly instead of starting one.`);
+	return result;
+}
 function turnFailure(error) {
 	const normalized = normalizeOutputError(error, {
 		defaultCode: "RUNTIME",
@@ -2183,11 +2327,13 @@ var SharedAcpRuntime = class {
 	options;
 	disconnect = new AbortController();
 	pending = /* @__PURE__ */ new Set();
+	controlChains = /* @__PURE__ */ new Map();
 	constructor(options) {
 		for (const name of [
 			"sessionStore",
 			"agentProcessEnv",
 			"mcpServers",
+			"sessionPermissions",
 			"processLifecycle",
 			"onPermissionRequest",
 			"elicitationModes"
@@ -2239,7 +2385,7 @@ var SharedAcpRuntime = class {
 	}
 	startTurn(input) {
 		this.assertOpen();
-		if (input.mode !== "prompt" || input.onPermissionRequest || input.onElicitation) invalidOption("Shared turns support prompt mode and the client's static permission policy; in-process callbacks and steering are unsupported.");
+		if (input.mode !== "prompt" || input.assertActive || input.onPermissionRequest || input.onElicitation) invalidOption("Shared turns support prompt mode and the client's static permission policy; in-process callbacks and steering are unsupported.");
 		if (!input.requestId.trim()) invalidOption("A shared turn requires a requestId.");
 		const sessionId = sharedRecordId(input.handle);
 		const prompt = toPromptInput(input.text, input.attachments);
@@ -2332,6 +2478,72 @@ var SharedAcpRuntime = class {
 		this.assertOpen();
 		return runtimeStatusFromRecord(await resolveSessionRecord(sharedRecordId(input.handle)));
 	}
+	async getCapabilities(input) {
+		this.assertOpen();
+		if (!input?.handle) return capabilitiesFromRecord(void 0);
+		return capabilitiesFromRecord(await readSessionRecord(sharedRecordId(input.handle)));
+	}
+	/**
+	* Preserves this client's control order, including caller-side persistence
+	* when talking to older owners. Updated owners checkpoint accepted controls
+	* themselves; serialization here cannot coordinate other legacy callers.
+	*/
+	chainControl(sessionId, run) {
+		const result = (this.controlChains.get(sessionId) ?? Promise.resolve()).then(run, run);
+		const chained = result.then(() => void 0, () => void 0);
+		this.controlChains.set(sessionId, chained);
+		chained.then(() => {
+			if (this.controlChains.get(sessionId) === chained) this.controlChains.delete(sessionId);
+		});
+		return result;
+	}
+	/**
+	* Checks this client's authority locally, then hands the control to the
+	* running owner. The check gates this client's dispatch only; it cannot gate
+	* controls other clients of the same owner send, and it cannot recall a
+	* control the owner already accepted.
+	*/
+	async dispatchControl(input, control, send) {
+		this.assertOpen();
+		const sessionId = sharedRecordId(input.handle);
+		const assertAuthority = () => {
+			this.assertOpen();
+			assertControlAuthority(input);
+		};
+		return await this.track(this.chainControl(sessionId, async () => {
+			assertAuthority();
+			return requireOwnerDispatch(await send(sessionId, assertAuthority), control);
+		}));
+	}
+	async setMode(input) {
+		await this.dispatchControl(input, "session/set_mode", async (sessionId, assertAuthority) => setSessionModeOnOwner({
+			sessionId,
+			modeId: input.mode,
+			timeoutMs: this.options.timeoutMs,
+			assertDispatch: assertAuthority
+		}));
+	}
+	async setModel(input) {
+		await this.dispatchControl(input, "session/set_model", async (sessionId, assertAuthority) => setSessionModelOnOwner({
+			sessionId,
+			modelId: input.model,
+			timeoutMs: this.options.timeoutMs,
+			assertDispatch: assertAuthority
+		}));
+	}
+	async setConfigOption(input) {
+		return (await this.dispatchControl(input, "session/set_config_option", async (sessionId, assertAuthority) => {
+			const configId = resolveSupportedConfigOptionId(await resolveSessionRecord(sessionId), input.key);
+			assertAuthority();
+			return await setSessionConfigOptionOnOwner({
+				sessionId,
+				configId,
+				value: input.value,
+				timeoutMs: this.options.timeoutMs,
+				assertDispatch: assertAuthority
+			});
+		})).response;
+	}
 	watchSession(input) {
 		this.assertOpen();
 		const signal = input.signal ? AbortSignal.any([input.signal, this.disconnect.signal]) : this.disconnect.signal;
@@ -2366,12 +2578,6 @@ function createSharedAcpRuntime(options) {
 //#endregion
 //#region src/runtime.ts
 const ACPX_BACKEND_ID = "acpx";
-const ACPX_CAPABILITIES = { controls: [
-	"session/set_mode",
-	"session/set_model",
-	"session/set_config_option",
-	"session/status"
-] };
 var AcpxRuntime = class {
 	options;
 	testOptions;
@@ -2471,6 +2677,7 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
+			assertActive: input.assertActive,
 			onElicitation: input.onElicitation,
 			onPermissionRequest: input.onPermissionRequest
 		}));
@@ -2504,6 +2711,7 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
+			assertActive: input.assertActive,
 			onElicitation: input.onElicitation,
 			onPermissionRequest: input.onPermissionRequest
 		});
@@ -2511,13 +2719,7 @@ var AcpxRuntime = class {
 	async getCapabilities(input) {
 		if (!input?.handle) return ACPX_CAPABILITIES;
 		const { handle } = this.resolveManagerHandle(input.handle);
-		const record = await this.options.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
-		if (!record?.acpx?.config_options) return ACPX_CAPABILITIES;
-		const configOptionKeys = Array.from(new Set(record.acpx.config_options.map((option) => option.id).filter((id) => typeof id === "string" && id.trim().length > 0)));
-		return {
-			...ACPX_CAPABILITIES,
-			...configOptionKeys.length > 0 ? { configOptionKeys } : {}
-		};
+		return capabilitiesFromRecord(await this.options.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
 	}
 	async getStatus(input) {
 		const { handle } = this.resolveManagerHandle(input.handle);
@@ -2616,6 +2818,6 @@ function createRuntimeStore(options) {
 	return createFileSessionStore(options);
 }
 //#endregion
-export { ACPX_BACKEND_ID, AcpRuntimeError, AcpxRuntime, DEFAULT_AGENT_NAME, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, SharedAcpRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, createSharedAcpRuntime, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isAcpRuntimeError, isRequestedModelUnsupportedError };
+export { ACPX_BACKEND_ID, AcpRuntimeError, AcpxRuntime, DEFAULT_AGENT_NAME, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, SharedAcpRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, createSharedAcpRuntime, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, inspectAgentModels, isAcpRuntimeError, isRequestedModelUnsupportedError };
 
 //# sourceMappingURL=runtime.js.map