acpx 0.16.0 → 0.17.0

package/dist/runtime.js

@@ -1,5 +1,8 @@
-import { A as isRequestedModelUnsupportedError, C as recordSessionUpdate, D as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, Dt as withTimeout, E as AcpClient, L as textPrompt, Mt as extractAcpError, Nt as isAcpResourceNotFoundError, O as REQUESTED_MODEL_UNSUPPORTED_REASONS, S as recordPromptSubmission, T as advertisedModelState, Z as assertPersistedKeyPolicy, _ as reconcileAgentSessionId, a as applyConfigOptionSelection, c as applyModelSelection, f as persistSessionOptions, g as createInitialSessionRecord, gt as writePrivateJsonFile, h as applyLifecycleSnapshotToRecord, i as connectAndLoadSession, jt as normalizeOutputError, k as RequestedModelUnsupportedError, l as applyRequestedModelIfAdvertised, m as applyConversation, n as runPromptTurn, o as applyConfigOptionsToRecord, ot as parseSessionRecord, p as sessionOptionsFromRecord, r as withConnectedSession, s as applyInitialModelSelection, st as serializeSessionRecordForDisk, t as LiveSessionCheckpoint, u as setDesiredModeId, v as cloneSessionAcpxState, w as trimConversationForRuntime, x as recordClientOperation, y as cloneSessionConversation } from "./live-checkpoint-BEfxBKCh.js";
+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 { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -733,7 +736,7 @@ function commandRecord(value) {
 	return value;
 }
 //#endregion
-//#region src/runtime/engine/manager.ts
+//#region src/runtime/engine/turn.ts
 function createDeferred() {
 	let resolve;
 	let reject;
@@ -746,22 +749,6 @@ function createDeferred() {
 		reject
 	};
 }
-async function settleAttempt(run) {
-	try {
-		return {
-			ok: true,
-			value: await run()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error
-		};
-	}
-}
-function firstFailedAttempt(attempts) {
-	return attempts.find((attempt) => !attempt.ok);
-}
 var AsyncEventQueue = class {
 	items = [];
 	waits = [];
@@ -798,17 +785,6 @@ var AsyncEventQueue = class {
 		}
 	}
 };
-function isoNow() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-function isUnsupportedSessionCloseError(error) {
-	const acp = extractAcpError(error);
-	if (!acp) return false;
-	if (acp.code === -32601 || acp.code === -32602) return true;
-	if (acp.code !== -32603 || !acp.data || typeof acp.data !== "object") return false;
-	const details = acp.data.details;
-	return typeof details === "string" && details.toLowerCase().includes("invalid params");
-}
 function toPromptInput(text, attachments) {
 	if (!attachments || attachments.length === 0) return text;
 	const blocks = [];
@@ -837,13 +813,6 @@ function toPromptInput(text, attachments) {
 	}
 	return blocks.length > 0 ? blocks : textPrompt(text);
 }
-function createRecordId(sessionKey, mode) {
-	if (mode === "persistent") return sessionKey;
-	return `${sessionKey}:oneshot:${randomUUID()}`;
-}
-function resumePolicyForSessionMode(mode) {
-	return mode === "persistent" ? "same-session-only" : "allow-new";
-}
 function legacyTerminalEventFromTurnResult(result) {
 	if (result.status === "failed") return {
 		type: "error",
@@ -858,6 +827,42 @@ function legacyTerminalEventFromTurnResult(result) {
 		...result._meta === void 0 ? {} : { _meta: result._meta }
 	};
 }
+//#endregion
+//#region src/runtime/engine/manager.ts
+async function settleAttempt(run) {
+	try {
+		return {
+			ok: true,
+			value: await run()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+function firstFailedAttempt(attempts) {
+	return attempts.find((attempt) => !attempt.ok);
+}
+function isoNow() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isUnsupportedSessionCloseError(error) {
+	const acp = extractAcpError(error);
+	if (!acp) return false;
+	if (acp.code === -32601 || acp.code === -32602) return true;
+	if (acp.code !== -32603 || !acp.data || typeof acp.data !== "object") return false;
+	const details = acp.data.details;
+	return typeof details === "string" && details.toLowerCase().includes("invalid params");
+}
+function createRecordId(sessionKey, mode) {
+	if (mode === "persistent") return sessionKey;
+	return `${sessionKey}:oneshot:${randomUUID()}`;
+}
+function resumePolicyForSessionMode(mode) {
+	return mode === "persistent" ? "same-session-only" : "allow-new";
+}
 function advertisedConfigOptionIds(record) {
 	const configOptions = record.acpx?.config_options;
 	if (!configOptions) return;
@@ -1179,9 +1184,11 @@ var AcpRuntimeManager = class {
 			agentArgv: agentArgv ? [...agentArgv] : void 0
 		}) : servers ?? []];
 	}
-	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption) {
+	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption, authority) {
 		await this.retrySessionCleanup(record.acpxRecordId);
+		assertControlAuthority(authority);
 		const owner = await this.readRetainedSessionOwner(record, { consume: false });
+		assertControlAuthority(authority);
 		if (owner) {
 			const ownedRecord = owner.projection?.record ?? record;
 			try {
@@ -1226,6 +1233,7 @@ var AcpRuntimeManager = class {
 				timeoutMs: this.options.timeoutMs,
 				resumePolicy: resumePolicyForSessionMode(sessionMode),
 				replacingConfigOption,
+				authority,
 				run
 			});
 			return {
@@ -1251,8 +1259,9 @@ var AcpRuntimeManager = class {
 		const key = `${input.mode}\0${input.sessionKey}`;
 		return await this.withManagerLock(this.ensureSessionLocks, key, run);
 	}
-	async withManagerLock(locks, key, run) {
+	async withManagerLock(locks, key, run, authority) {
 		this.assertOpen();
+		assertControlAuthority(authority);
 		const previous = locks.get(key) ?? Promise.resolve();
 		let release;
 		const gate = new Promise((resolve) => {
@@ -1263,6 +1272,7 @@ var AcpRuntimeManager = class {
 		await previous;
 		try {
 			this.assertOpen();
+			assertControlAuthority(authority);
 			return await run();
 		} finally {
 			release();
@@ -1685,24 +1695,24 @@ var AcpRuntimeManager = class {
 		return {
 			hasActivePrompt: () => turn.client.hasActivePrompt(),
 			requestCancelActivePrompt: async () => await this.requestRuntimeTurnCancel(task, turn),
-			setSessionMode: async (modeId) => {
+			setSessionMode: async (modeId, authority) => {
 				await this.waitForRuntimeControlSession(task, turn);
-				await turn.client.setSessionMode(turn.activeSessionId, modeId);
+				await turn.client.setSessionMode(turn.activeSessionId, modeId, authority);
 				const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
 				nextState.desired_mode_id = modeId;
 				turn.acpxState = nextState;
 			},
-			setSessionModel: async (modelId) => {
+			setSessionModel: async (modelId, authority) => {
 				await this.waitForRuntimeControlSession(task, turn);
 				const models = advertisedModelState(turn.acpxState);
-				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models);
+				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models, authority);
 				turn.acpxState = applyModelSelection(turn.acpxState, modelId, response);
 				return response;
 			},
-			setSessionConfigOption: async (configId, value) => {
-				return (await task.state.activeController.setResolvedSessionConfigOption(configId, value)).response;
+			setSessionConfigOption: async (configId, value, authority) => {
+				return (await task.state.activeController.setResolvedSessionConfigOption(configId, value, authority)).response;
 			},
-			setResolvedSessionConfigOption: async (configId, value) => await this.setRuntimeResolvedSessionConfigOption(task, turn, configId, value)
+			setResolvedSessionConfigOption: async (configId, value, authority) => await this.setRuntimeResolvedSessionConfigOption(task, turn, configId, value, authority)
 		};
 	}
 	async waitForRuntimeControlSession(task, turn) {
@@ -1715,14 +1725,14 @@ var AcpRuntimeManager = class {
 		task.state.pendingCancel = true;
 		return true;
 	}
-	async setRuntimeResolvedSessionConfigOption(task, turn, configId, value) {
+	async setRuntimeResolvedSessionConfigOption(task, turn, configId, value, authority) {
 		await this.waitForRuntimeControlSession(task, turn);
 		const resolvedConfigId = resolveSupportedConfigOptionId({
 			...turn.record,
 			acpx: turn.acpxState ?? void 0
 		}, configId);
 		const modelConfigId = advertisedModelState(turn.acpxState)?.configId;
-		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value);
+		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value, authority);
 		turn.acpxState = applyConfigOptionSelection(turn.acpxState, resolvedConfigId, value, response, modelConfigId);
 		return {
 			configId: resolvedConfigId,
@@ -1879,49 +1889,52 @@ var AcpRuntimeManager = class {
 		if (owner) await this.flushSessionOwner(owner);
 		return runtimeStatusFromRecord(await this.requireRecord(recordId));
 	}
-	async setMode(handle, mode, sessionMode = "persistent") {
+	async setMode(handle, mode, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModeWithOwnership(handle, mode, sessionMode));
+		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModeWithOwnership(handle, mode, sessionMode, authority), authority);
 	}
-	async setModeWithOwnership(handle, mode, sessionMode) {
+	async setModeWithOwnership(handle, mode, sessionMode, authority) {
 		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);
+		if (controller) await controller.setSessionMode(mode, authority);
 		else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId }) => {
-			await client.setSessionMode(sessionId, mode);
-		})).record;
+			await client.setSessionMode(sessionId, mode, authority);
+		}, void 0, authority)).record;
 		setDesiredModeId(targetRecord, mode);
 		await this.options.sessionStore.save(targetRecord);
 	}
-	async setModel(handle, model, sessionMode = "persistent") {
+	async setModel(handle, model, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModelWithOwnership(handle, model, sessionMode));
+		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModelWithOwnership(handle, model, sessionMode, authority), authority);
 	}
-	async setModelWithOwnership(handle, model, sessionMode) {
+	async setModelWithOwnership(handle, model, sessionMode, authority) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
-			const response = await controller.setSessionModel(model);
+			const response = await controller.setSessionModel(model, authority);
 			record.acpx = applyModelSelection(record.acpx, model, response);
 			await this.options.sessionStore.save(record);
 			return;
 		}
 		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
-			const response = await client.setSessionModel(sessionId, model, advertisedModelState(connectedRecord.acpx));
+			const response = await client.setSessionModel(sessionId, model, advertisedModelState(connectedRecord.acpx), authority);
 			connectedRecord.acpx = applyModelSelection(connectedRecord.acpx, model, response);
-		}, { key: "model" });
+		}, { key: "model" }, authority);
 		await this.options.sessionStore.save(result.record);
 	}
-	async setConfigOption(handle, key, value, sessionMode = "persistent") {
+	async setConfigOption(handle, key, value, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setConfigOptionWithOwnership(handle, key, value, sessionMode));
+		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setConfigOptionWithOwnership(handle, key, value, sessionMode, authority), authority);
 	}
-	async setConfigOptionWithOwnership(handle, key, value, sessionMode) {
+	async setConfigOptionWithOwnership(handle, key, value, sessionMode, authority) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
-			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value);
+			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value, authority);
 			record.acpx = applyConfigOptionSelection(record.acpx, configId, value, response);
 			await this.options.sessionStore.save(record);
 			return response;
@@ -1929,13 +1942,13 @@ var AcpRuntimeManager = class {
 		const result = 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);
+			const response = await client.setSessionConfigOption(sessionId, configId, value, authority);
 			connectedRecord.acpx = applyConfigOptionSelection(connectedRecord.acpx, configId, value, response, modelConfigId);
 			return response;
 		}, {
 			key,
 			resolve: (connectedRecord) => resolveSupportedConfigOptionId(connectedRecord, key)
-		});
+		}, authority);
 		await this.options.sessionStore.save(result.record);
 		return result.value;
 	}
@@ -2125,6 +2138,232 @@ function writeHandleState(handle, state) {
 	handle.agentSessionId = state.agentSessionId;
 }
 //#endregion
+//#region src/runtime/shared.ts
+const SHARED_BACKEND = "acpx-shared";
+function invalidOption(message) {
+	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", message);
+}
+function sharedHandle(record) {
+	return {
+		backend: SHARED_BACKEND,
+		sessionKey: record.name ?? "",
+		runtimeSessionName: record.acpxRecordId,
+		acpxRecordId: record.acpxRecordId,
+		backendSessionId: record.acpSessionId,
+		agentSessionId: record.agentSessionId,
+		cwd: record.cwd
+	};
+}
+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;
+}
+function turnFailure(error) {
+	const normalized = normalizeOutputError(error, {
+		defaultCode: "RUNTIME",
+		origin: "queue"
+	});
+	if (normalized.detailCode === "QUEUE_REQUEST_CANCELLED") return {
+		status: "cancelled",
+		stopReason: "cancelled"
+	};
+	return {
+		status: "failed",
+		error: {
+			message: normalized.message,
+			code: normalized.code,
+			detailCode: normalized.detailCode,
+			retryable: normalized.retryable
+		}
+	};
+}
+/** A client of the CLI's local session owner. Shutdown detaches this client. */
+var SharedAcpRuntime = class {
+	registry;
+	options;
+	disconnect = new AbortController();
+	pending = /* @__PURE__ */ new Set();
+	constructor(options) {
+		for (const name of [
+			"sessionStore",
+			"agentProcessEnv",
+			"mcpServers",
+			"processLifecycle",
+			"onPermissionRequest",
+			"elicitationModes"
+		]) if (Object.hasOwn(options, name)) invalidOption(`${name} belongs to the in-process runtime and is not supported by shared sessions.`);
+		this.options = {
+			...options,
+			cwd: path.resolve(options.cwd),
+			authCredentials: options.authCredentials ? { ...options.authCredentials } : void 0
+		};
+		this.registry = options.agentRegistry ?? createAgentRegistry();
+	}
+	assertOpen() {
+		if (this.disconnect.signal.aborted) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "Shared ACP runtime is shut down.");
+	}
+	track(task) {
+		this.pending.add(task);
+		task.then(() => this.pending.delete(task), () => this.pending.delete(task));
+		return task;
+	}
+	sessionOptions(input) {
+		if (!input.agent.trim()) invalidOption("ACP agent id is required.");
+		return {
+			...normalizeAgentCommandInput(this.registry.resolve(input.agent)),
+			cwd: path.resolve(input.cwd ?? this.options.cwd),
+			name: input.sessionKey.trim() || void 0
+		};
+	}
+	async findSession(input) {
+		this.assertOpen();
+		const record = await findSession(this.sessionOptions(input));
+		return record ? sharedHandle(record) : void 0;
+	}
+	ensureSession(input) {
+		this.assertOpen();
+		if (input.mode !== "persistent") invalidOption("Shared sessions require persistent mode; use the in-process runtime for oneshot sessions.");
+		const session = this.sessionOptions(input);
+		return this.track(ensureSession({
+			...this.options,
+			...session,
+			walkBoundary: session.cwd,
+			sessionOptions: input.sessionOptions,
+			resumeSessionId: input.resumeSessionId,
+			handleProcessInterrupts: false,
+			signal: this.disconnect.signal
+		}).then(({ record }) => {
+			this.assertOpen();
+			return sharedHandle(record);
+		}));
+	}
+	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.requestId.trim()) invalidOption("A shared turn requires a requestId.");
+		const sessionId = sharedRecordId(input.handle);
+		const prompt = toPromptInput(input.text, input.attachments);
+		const events = new AsyncEventQueue();
+		const promptStarted = createDeferred();
+		promptStarted.promise.catch(() => {});
+		let accepted = false;
+		let settled = false;
+		let cancelRequested = input.signal?.aborted === true;
+		let cancellation;
+		const cancel = async () => {
+			cancelRequested = true;
+			if (!accepted || settled) return;
+			cancellation ??= tryCancelOnRunningOwner({
+				sessionId,
+				targetRequestId: input.requestId
+			}).then(() => {});
+			await cancellation;
+		};
+		const onAbort = () => {
+			cancel().catch(() => {});
+		};
+		input.signal?.addEventListener("abort", onAbort, { once: true });
+		const run = async () => {
+			if (cancelRequested) return {
+				status: "cancelled",
+				stopReason: "cancelled"
+			};
+			if ((await resolveSessionRecord(sessionId)).closed) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "Shared session is closed; ensure it again before submitting a turn.");
+			if (cancelRequested) return {
+				status: "cancelled",
+				stopReason: "cancelled"
+			};
+			const result = await sendSession({
+				...this.options,
+				sessionId,
+				requestId: input.requestId,
+				prompt: typeof prompt === "string" ? textPrompt(prompt) : prompt,
+				resumePolicy: "same-session-only",
+				requireSharedRuntime: true,
+				signal: this.disconnect.signal,
+				timeoutMs: input.timeoutMs ?? this.options.timeoutMs,
+				queueOwnerArgs: [fileURLToPath(import.meta.resolve("acpx/dist/cli.js")), "__queue-owner"],
+				onQueueAccepted: () => {
+					accepted = true;
+					if (cancelRequested) cancel().catch(() => {});
+				},
+				onPromptStarted: () => promptStarted.resolve(),
+				outputFormatter: {
+					...DISCARD_OUTPUT_FORMATTER,
+					onAcpMessage: (message) => {
+						const event = parsePromptEventLine(JSON.stringify(message));
+						if (event) events.push(event);
+					}
+				},
+				errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
+				waitForCompletion: true
+			});
+			if ("queued" in result) throw new AcpRuntimeError("ACP_TURN_FAILED", "Shared turn ended without a completion result.");
+			return {
+				status: result.stopReason === "cancelled" ? "cancelled" : "completed",
+				stopReason: result.stopReason,
+				_meta: result._meta
+			};
+		};
+		const result = this.track(run().catch(turnFailure).finally(() => {
+			settled = true;
+			promptStarted.reject(new AcpRuntimeError("ACP_TURN_FAILED", "Turn settled before its prompt was written."));
+			input.signal?.removeEventListener("abort", onAbort);
+			events.close();
+		}));
+		return {
+			requestId: input.requestId,
+			promptStarted: promptStarted.promise,
+			events: events.iterate(),
+			result,
+			cancel,
+			closeStream: async () => {
+				events.clear();
+				events.close();
+			}
+		};
+	}
+	async *runTurn(input) {
+		const turn = this.startTurn(input);
+		yield* turn.events;
+		yield legacyTerminalEventFromTurnResult(await turn.result);
+	}
+	async getStatus(input) {
+		this.assertOpen();
+		return runtimeStatusFromRecord(await resolveSessionRecord(sharedRecordId(input.handle)));
+	}
+	watchSession(input) {
+		this.assertOpen();
+		const signal = input.signal ? AbortSignal.any([input.signal, this.disconnect.signal]) : this.disconnect.signal;
+		const recordId = sharedRecordId(input.handle);
+		const record = readSessionRecord(recordId).then((value) => {
+			if (!value || value.acpxRecordId !== recordId) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "Shared session record is unavailable.");
+			return value;
+		});
+		record.catch(() => {});
+		return watchSession({
+			record,
+			cursor: input.cursor,
+			signal
+		});
+	}
+	async cancel(input) {
+		this.assertOpen();
+		await this.track(cancelSessionPrompt({ sessionId: sharedRecordId(input.handle) }));
+	}
+	async close(input) {
+		this.assertOpen();
+		await this.track(closeSession(sharedRecordId(input.handle)));
+	}
+	async shutdown() {
+		this.disconnect.abort(new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "Shared client detached; submitted work may still be running."));
+		await Promise.allSettled(this.pending);
+	}
+};
+function createSharedAcpRuntime(options) {
+	return new SharedAcpRuntime(options);
+}
+//#endregion
 //#region src/runtime.ts
 const ACPX_BACKEND_ID = "acpx";
 const ACPX_CAPABILITIES = { controls: [
@@ -2286,15 +2525,15 @@ var AcpxRuntime = class {
 	}
 	async setMode(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		await (await this.getManager()).setMode(handle, input.mode, state.mode);
+		await (await this.getManager()).setMode(handle, input.mode, state.mode, input);
 	}
 	async setModel(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		await (await this.getManager()).setModel(handle, input.model, state.mode);
+		await (await this.getManager()).setModel(handle, input.model, state.mode, input);
 	}
 	async setConfigOption(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		return await (await this.getManager()).setConfigOption(handle, input.key, input.value, state.mode);
+		return await (await this.getManager()).setConfigOption(handle, input.key, input.value, state.mode, input);
 	}
 	async cancel(input) {
 		const { handle } = this.resolveManagerHandle(input.handle);
@@ -2377,6 +2616,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, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, 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, isAcpRuntimeError, isRequestedModelUnsupportedError };
 
 //# sourceMappingURL=runtime.js.map