acpx 0.13.1 → 0.14.0

package/dist/runtime.d.ts

@@ -1,9 +1,9 @@
 import { _ as SessionRecord, a as AcpElicitationHandler, c as AcpElicitationResponse, f as McpServer$1, h as PermissionPolicy, i as AcpElicitationContext, l as AcpPermissionDecision, m as PermissionMode, n as SystemPromptOption, o as AcpElicitationMode, p as NonInteractivePermissionPolicy, s as AcpElicitationRequest, t as SessionAgentOptions, u as AcpPermissionRequest } from "./session-options-DwRDODlr.js";
-import { a as RequestedModelUnsupportedErrorCode, i as RequestedModelUnsupportedError, n as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, o as RequestedModelUnsupportedReason, r as REQUESTED_MODEL_UNSUPPORTED_REASONS, s as isRequestedModelUnsupportedError, t as AcpClient } from "./client-CxNllqui.js";
+import { a as RequestedModelUnsupportedErrorCode, i as RequestedModelUnsupportedError, n as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, o as RequestedModelUnsupportedReason, r as REQUESTED_MODEL_UNSUPPORTED_REASONS, s as isRequestedModelUnsupportedError, t as AcpClient } from "./client-IfFkZz0S.js";
 import fs from "node:fs";
-import { ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
+import { SetSessionConfigOptionResponse, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
 //#region src/agent-registry.d.ts
-declare const DEFAULT_AGENT_NAME = "codex";
+export declare const DEFAULT_AGENT_NAME = "codex";
 //#endregion
 //#region src/runtime/public/contract.d.ts
 type AcpRuntimePromptMode = "prompt" | "steer";
@@ -236,7 +236,7 @@ type AcpRuntimeTurnResult = {
 };
 interface AcpRuntimeTurn {
   readonly requestId: string;
-  /** Resolves after `connection.prompt()` returns its request promise. */
+  /** Resolves after the underlying writable transport accepts the prompt request. */
   readonly promptStarted: Promise<void>;
   readonly events: AsyncIterable<AcpRuntimeEvent>;
   /**
@@ -276,7 +276,7 @@ interface AcpRuntime {
     handle: AcpRuntimeHandle;
     key: string;
     value: string;
-  }): Promise<void>;
+  }): Promise<SetSessionConfigOptionResponse | void>;
   doctor?(): Promise<AcpRuntimeDoctorReport>;
   cancel(input: {
     handle: AcpRuntimeHandle;
@@ -356,7 +356,6 @@ declare class AcpRuntimeManager {
   private canRetainPersistentSessionOwner;
   private withRuntimeControlSession;
   private refreshOwnedRecordLifecycle;
-  private finishBufferedOwnerControl;
   ensureSession(input: RuntimeEnsureInput): Promise<SessionRecord>;
   private withEnsureSessionLock;
   private withManagerLock;
@@ -366,7 +365,7 @@ declare class AcpRuntimeManager {
   private reuseRuntimeSession;
   private closeConflictingPersistentSession;
   private createOwnedRuntimeSession;
-  private createAndSaveRuntimeRecord;
+  private prepareInitialRuntimeRecord;
   private retainInitializedSessionOwner;
   startTurn(input: {
     handle: AcpRuntimeHandle;
@@ -396,10 +395,8 @@ declare class AcpRuntimeManager {
   private waitForRuntimeControlSession;
   private requestRuntimeTurnCancel;
   private setRuntimeResolvedSessionConfigOption;
-  private applyRuntimeConfigOptionState;
   private emitRuntimeTurnEvent;
   private connectRuntimeTurn;
-  private drainRuntimeConnectionUpdates;
   private connectRuntimeTurnClient;
   private publishRuntimeTurnController;
   private resolveRuntimeTurnReady;
@@ -427,7 +424,7 @@ declare class AcpRuntimeManager {
   getStatus(handle: AcpRuntimeHandle): Promise<AcpRuntimeStatus>;
   setMode(handle: AcpRuntimeHandle, mode: string, sessionMode?: "persistent" | "oneshot"): Promise<void>;
   private setModeWithOwnership;
-  setConfigOption(handle: AcpRuntimeHandle, key: string, value: string, sessionMode?: "persistent" | "oneshot"): Promise<void>;
+  setConfigOption(handle: AcpRuntimeHandle, key: string, value: string, sessionMode?: "persistent" | "oneshot"): Promise<SetSessionConfigOptionResponse>;
   private setConfigOptionWithOwnership;
   cancel(handle: AcpRuntimeHandle): Promise<void>;
   close(handle: AcpRuntimeHandle, options?: {
@@ -445,19 +442,19 @@ declare class AcpRuntimeManager {
 }
 //#endregion
 //#region src/runtime/public/file-session-store.d.ts
-declare function createFileSessionStore(options: AcpFileSessionStoreOptions): AcpSessionStore;
+export declare function createFileSessionStore(options: AcpFileSessionStoreOptions): AcpSessionStore;
 //#endregion
 //#region src/runtime/public/errors.d.ts
 declare const ACP_ERROR_CODES: readonly ["ACP_BACKEND_MISSING", "ACP_BACKEND_UNAVAILABLE", "ACP_BACKEND_UNSUPPORTED_CONTROL", "ACP_DISPATCH_DISABLED", "ACP_INVALID_RUNTIME_OPTION", "ACP_SESSION_INIT_FAILED", "ACP_TURN_FAILED"];
 type AcpRuntimeErrorCode = (typeof ACP_ERROR_CODES)[number];
-declare class AcpRuntimeError extends Error {
+export declare class AcpRuntimeError extends Error {
   readonly code: AcpRuntimeErrorCode;
   readonly cause?: unknown;
   constructor(code: AcpRuntimeErrorCode, message: string, options?: {
     cause?: unknown;
   });
 }
-declare function isAcpRuntimeError(value: unknown): value is AcpRuntimeError;
+export declare function isAcpRuntimeError(value: unknown): value is AcpRuntimeError;
 //#endregion
 //#region src/runtime/public/shared.d.ts
 type AcpxHandleState = {
@@ -471,20 +468,20 @@ type AcpxHandleState = {
 };
 //#endregion
 //#region src/runtime/public/handle-state.d.ts
-declare function encodeAcpxRuntimeHandleState(state: AcpxHandleState): string;
-declare function decodeAcpxRuntimeHandleState(runtimeSessionName: string): AcpxHandleState | null;
+export declare function encodeAcpxRuntimeHandleState(state: AcpxHandleState): string;
+export declare function decodeAcpxRuntimeHandleState(runtimeSessionName: string): AcpxHandleState | null;
 //#endregion
 //#region src/runtime.d.ts
-declare const ACPX_BACKEND_ID = "acpx";
+export declare const ACPX_BACKEND_ID = "acpx";
 type AcpxRuntimeLike = AcpRuntime & {
   probeAvailability(): Promise<void>;
   isHealthy(): boolean;
   doctor(): Promise<AcpRuntimeDoctorReport>;
 };
-declare function createAgentRegistry(params?: {
+export declare function createAgentRegistry(params?: {
   overrides?: Record<string, string | string[]>;
 }): AcpAgentRegistry;
-declare class AcpxRuntime implements AcpxRuntimeLike {
+export declare class AcpxRuntime implements AcpxRuntimeLike {
   private readonly options;
   private readonly testOptions?;
   private healthy;
@@ -532,7 +529,7 @@ declare class AcpxRuntime implements AcpxRuntimeLike {
     handle: AcpRuntimeHandle;
     key: string;
     value: string;
-  }): Promise<void>;
+  }): Promise<SetSessionConfigOptionResponse>;
   cancel(input: {
     handle: AcpRuntimeHandle;
     reason?: string;
@@ -547,10 +544,10 @@ declare class AcpxRuntime implements AcpxRuntimeLike {
   private resolveManagerHandle;
   private resolveHandleState;
 }
-declare function createAcpRuntime(options: AcpRuntimeOptions): AcpxRuntime;
-declare function createRuntimeStore(options: {
+export declare function createAcpRuntime(options: AcpRuntimeOptions): AcpxRuntime;
+export declare function createRuntimeStore(options: {
   stateDir: string;
 }): AcpSessionStore;
 //#endregion
-export { ACPX_BACKEND_ID, type AcpAgentRegistry, type AcpElicitationContext, type AcpElicitationHandler, type AcpElicitationMode, type AcpElicitationRequest, type AcpElicitationResponse, type AcpFileSessionStoreOptions, type AcpPermissionDecision, type AcpPermissionRequest, type AcpRuntime, type AcpRuntimeAvailableCommand, type AcpRuntimeCapabilities, type AcpRuntimeDoctorReport, type AcpRuntimeEnsureInput, AcpRuntimeError, type AcpRuntimeErrorCode, type AcpRuntimeEvent, type AcpRuntimeHandle, type AcpRuntimeOptions, type AcpRuntimePromptMode, type AcpRuntimeSessionMode, type AcpRuntimeSessionModels, type AcpRuntimeSessionUsage, type AcpRuntimeStatus, type AcpRuntimeTurn, type AcpRuntimeTurnAttachment, type AcpRuntimeTurnInput, type AcpRuntimeTurnResult, type AcpRuntimeTurnResultError, type AcpRuntimeUsageBreakdown, type AcpRuntimeUsageCost, type AcpSessionRecord, type AcpSessionStore, type AcpSessionUpdateTag, type AcpTextDeltaOriginMeta, AcpxRuntime, DEFAULT_AGENT_NAME, type PermissionPolicy, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, type RequestedModelUnsupportedErrorCode, type RequestedModelUnsupportedReason, type SessionAgentOptions, type SystemPromptOption, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isAcpRuntimeError, isRequestedModelUnsupportedError };
+export { type AcpAgentRegistry, type AcpElicitationContext, type AcpElicitationHandler, type AcpElicitationMode, type AcpElicitationRequest, type AcpElicitationResponse, type AcpFileSessionStoreOptions, type AcpPermissionDecision, type AcpPermissionRequest, type AcpRuntime, type AcpRuntimeAvailableCommand, type AcpRuntimeCapabilities, type AcpRuntimeDoctorReport, type AcpRuntimeEnsureInput, type AcpRuntimeErrorCode, type AcpRuntimeEvent, type AcpRuntimeHandle, type AcpRuntimeOptions, type AcpRuntimePromptMode, type AcpRuntimeSessionMode, type AcpRuntimeSessionModels, type AcpRuntimeSessionUsage, type AcpRuntimeStatus, type AcpRuntimeTurn, type AcpRuntimeTurnAttachment, type AcpRuntimeTurnInput, type AcpRuntimeTurnResult, type AcpRuntimeTurnResultError, type AcpRuntimeUsageBreakdown, type AcpRuntimeUsageCost, type AcpSessionRecord, type AcpSessionStore, type AcpSessionUpdateTag, type AcpTextDeltaOriginMeta, type PermissionPolicy, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, type RequestedModelUnsupportedErrorCode, type RequestedModelUnsupportedReason, type SessionAgentOptions, type SystemPromptOption, isRequestedModelUnsupportedError };
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","names":[],"sources":["../src/agent-registry.ts","../src/runtime/public/contract.ts","../src/runtime/engine/manager.ts","../src/runtime/public/file-session-store.ts","../src/runtime/public/errors.ts","../src/runtime/public/shared.ts","../src/runtime/public/handle-state.ts","../src/runtime.ts"],"mappings":"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"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../src/agent-registry.ts","../src/runtime/public/contract.ts","../src/runtime/engine/manager.ts","../src/runtime/public/file-session-store.ts","../src/runtime/public/errors.ts","../src/runtime/public/shared.ts","../src/runtime/public/handle-state.ts","../src/runtime.ts"],"mappings":"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"}

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { A as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, D as applyLifecycleSnapshotToRecord, E as applyConversation, F as modelStateFromConfigOptions, Ft as normalizeAgentName, Ht as normalizeOutputError, I as normalizeAgentCommandInput, It as resolveAgentArgv, Lt as resolveAgentCommand, M as RequestedModelUnsupportedError, Mt as withTimeout, Nt as DEFAULT_AGENT_NAME, O as reconcileAgentSessionId, Ot as textPrompt, P as isRequestedModelUnsupportedError, Pt as listBuiltInAgents, Rt as resolveCanonicalAgentName, S as advertisedModelState, T as sessionOptionsFromRecord, Ut as extractAcpError, Wt as isAcpResourceNotFoundError, _ as createSessionConversation, a as applyRequestedModelIfAdvertised, b as recordSessionUpdate, c as setCurrentModelId, d as setDesiredModelId, dt as serializeSessionRecordForDisk, et as createAtomicWriteTempPath, f as syncAdvertisedModelState, g as cloneSessionConversation, h as cloneSessionAcpxState, i as connectAndLoadSession, j as REQUESTED_MODEL_UNSUPPORTED_REASONS, k as AcpClient, l as setDesiredConfigOption, m as applyConfigOptionsToState, mt as defaultSessionEventLog, n as runPromptTurn, o as currentModelIdFromSetModelResponse, p as applyConfigOptionsToRecord, r as withConnectedSession, s as clearDesiredConfigOption, t as LiveSessionCheckpoint, tt as assertPersistedKeyPolicy, u as setDesiredModeId, ut as parseSessionRecord, v as recordClientOperation, w as persistSessionOptions, x as trimConversationForRuntime, y as recordPromptSubmission } from "./live-checkpoint-BSIrfgVo.js";
+import { A as RequestedModelUnsupportedError, At as DEFAULT_AGENT_NAME, Bt as extractAcpError, C as sessionOptionsFromRecord, D as AcpClient, E as reconcileAgentSessionId, Ft as resolveCanonicalAgentName, M as modelStateFromConfigOptions, Mt as normalizeAgentName, N as normalizeAgentCommandInput, Nt as resolveAgentArgv, O as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, Pt as resolveAgentCommand, Q as assertPersistedKeyPolicy, S as persistSessionOptions, T as applyLifecycleSnapshotToRecord, Tt as textPrompt, Vt as isAcpResourceNotFoundError, Z as createAtomicWriteTempPath, _ as recordPromptSubmission, a as applyConfigOptionSelection, b as advertisedModelState, c as applyRequestedModelIfAdvertised, ct as serializeSessionRecordForDisk, d as setDesiredModeId, dt as defaultSessionEventLog, f as syncAdvertisedModelState, g as recordClientOperation, h as createSessionConversation, i as connectAndLoadSession, j as isRequestedModelUnsupportedError, jt as listBuiltInAgents, k as REQUESTED_MODEL_UNSUPPORTED_REASONS, kt as withTimeout, l as currentModelIdFromSetModelResponse, m as cloneSessionConversation, n as runPromptTurn, o as applyConfigOptionsToRecord, p as cloneSessionAcpxState, r as withConnectedSession, s as applyModelSelection, st as parseSessionRecord, t as LiveSessionCheckpoint, u as setCurrentModelId, v as recordSessionUpdate, w as applyConversation, y as trimConversationForRuntime, zt as normalizeOutputError } from "./live-checkpoint-BW9JivEG.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -221,7 +221,7 @@ function summarizeToolInput(rawInput) {
 }
 function truncateToolSummary(value) {
 	if (value.length <= TOOL_OUTPUT_SUMMARY_MAX_CHARS) return value;
-	return `${value.slice(0, TOOL_OUTPUT_SUMMARY_MAX_CHARS - 1)}…`;
+	return `${value.slice(0, 499)}…`;
 }
 function readToolContentText(value) {
 	const record = isRecord(value) ? value : void 0;
@@ -749,30 +749,6 @@ function resolveSupportedConfigOptionId(record, configId) {
 	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}.`);
 }
-function applyConfigOptionResponseToTurn(turn, response) {
-	if (!response?.configOptions) return;
-	turn.acpxState = applyConfigOptionsToState(turn.acpxState, response.configOptions);
-}
-function applyDesiredConfigOptionToTurn(turn, configId, value) {
-	const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
-	if (configId === modelStateFromConfigOptions(nextState.config_options)?.configId) {
-		nextState.session_options = {
-			...nextState.session_options,
-			model: value
-		};
-		clearDesiredConfigOption(nextState, configId);
-	} else if (configId === "mode") nextState.desired_mode_id = value;
-	else nextState.desired_config_options = {
-		...nextState.desired_config_options,
-		[configId]: value
-	};
-	turn.acpxState = nextState;
-}
-function applyDesiredConfigOptionToRecord(record, configId, value) {
-	if (configId === modelStateFromConfigOptions(record.acpx?.config_options)?.configId) setDesiredModelId(record, value, configId);
-	else if (configId === "mode") setDesiredModeId(record, value);
-	else setDesiredConfigOption(record, configId, value);
-}
 async function createOrLoadRuntimeSession(client, resumeSessionId, cwd) {
 	if (resumeSessionId) {
 		if (client.supportsResumeSession()) {
@@ -830,18 +806,11 @@ var AcpRuntimeManager = class {
 		const active = owner.activeTurn;
 		if (active) {
 			const { task, turn } = active;
-			if (turn.connectionUpdates) {
-				turn.connectionUpdates.push(notification);
-				this.emitRuntimeTurnEvent(task, {
-					jsonrpc: "2.0",
-					method: "session/update",
-					params: notification
-				});
-				return;
-			}
-			turn.acpxState = recordSessionUpdate(turn.conversation, turn.acpxState, notification);
+			if (turn.connected) {
+				turn.acpxState = recordSessionUpdate(turn.conversation, turn.acpxState, notification);
+				turn.liveCheckpoint.request();
+			} else turn.record.acpx = recordSessionUpdate(turn.conversation, turn.record.acpx, notification);
 			trimConversationForRuntime(turn.conversation);
-			turn.liveCheckpoint.request();
 			this.emitRuntimeTurnEvent(task, {
 				jsonrpc: "2.0",
 				method: "session/update",
@@ -858,7 +827,7 @@ var AcpRuntimeManager = class {
 			owner.pendingSessionUpdates.push(notification);
 			return;
 		}
-		projection.acpxState = recordSessionUpdate(projection.conversation, projection.acpxState, notification);
+		projection.record.acpx = recordSessionUpdate(projection.conversation, projection.record.acpx, notification);
 		trimConversationForRuntime(projection.conversation);
 		projection.checkpoint.request();
 	}
@@ -866,30 +835,30 @@ var AcpRuntimeManager = class {
 		const active = owner.activeTurn;
 		if (!active) return;
 		const { task, turn } = active;
-		turn.acpxState = recordClientOperation(turn.conversation, turn.acpxState, operation);
+		if (turn.connected) {
+			turn.acpxState = recordClientOperation(turn.conversation, turn.acpxState, operation);
+			turn.liveCheckpoint.request();
+		} else turn.record.acpx = recordClientOperation(turn.conversation, turn.record.acpx, operation);
 		trimConversationForRuntime(turn.conversation);
-		turn.liveCheckpoint.request();
 		this.emitRuntimeTurnEvent(task, {
 			type: "client_operation",
 			...operation
 		});
 	}
-	attachIdleProjection(owner, record, conversation = cloneSessionConversation(record), acpxState = cloneSessionAcpxState(record.acpx)) {
-		let projection;
-		projection = {
+	attachIdleProjection(owner, record, conversation = cloneSessionConversation(record), acpxState = record.acpx) {
+		record.acpx = acpxState;
+		owner.projection = {
 			record,
 			conversation,
-			acpxState,
 			checkpoint: new LiveSessionCheckpoint({ save: async () => {
+				if (!owner.recordId) return;
 				record.lastUsedAt = isoNow();
-				record.acpx = projection.acpxState;
-				applyConversation(record, projection.conversation);
+				applyConversation(record, conversation);
 				applyLifecycleSnapshotToRecord(record, owner.client.getAgentLifecycleSnapshot());
 				await this.refreshClosedState(record);
 				await this.options.sessionStore.save(record);
 			} })
 		};
-		owner.projection = projection;
 		owner.activeTurn = void 0;
 		this.drainPendingSessionUpdates(owner);
 	}
@@ -961,11 +930,10 @@ var AcpRuntimeManager = class {
 	canRetainPersistentSessionOwner(owner, record) {
 		return owner.mode === "persistent" && !record.closed && !(owner.client.hasUnresolvedPrompt?.() ?? false) && owner.client.hasReusableSession(record.acpSessionId);
 	}
-	async withRuntimeControlSession(record, sessionMode, run) {
+	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption) {
 		const owner = await this.readRetainedSessionOwner(record, { consume: false });
 		if (owner) {
 			const ownedRecord = owner.projection?.record ?? record;
-			owner.bufferSessionUpdates = true;
 			try {
 				const value = await run({
 					client: owner.client,
@@ -978,7 +946,7 @@ var AcpRuntimeManager = class {
 					record: ownedRecord
 				};
 			} finally {
-				await this.finishBufferedOwnerControl(owner, ownedRecord);
+				await this.flushSessionOwner(owner);
 			}
 		}
 		const result = await withConnectedSession({
@@ -995,6 +963,7 @@ var AcpRuntimeManager = class {
 			verbose: this.options.verbose,
 			timeoutMs: this.options.timeoutMs,
 			resumePolicy: resumePolicyForSessionMode(sessionMode),
+			replacingConfigOption,
 			run
 		});
 		return {
@@ -1010,17 +979,6 @@ var AcpRuntimeManager = class {
 		record.agentCapabilities = owner.client.initializeResult?.agentCapabilities;
 		applyLifecycleSnapshotToRecord(record, owner.client.getAgentLifecycleSnapshot());
 	}
-	async finishBufferedOwnerControl(owner, record) {
-		const projection = owner.projection;
-		if (projection) projection.acpxState = cloneSessionAcpxState(record.acpx);
-		owner.bufferSessionUpdates = false;
-		this.drainPendingSessionUpdates(owner);
-		if (projection) {
-			record.acpx = projection.acpxState;
-			applyConversation(record, projection.conversation);
-			await projection.checkpoint.flush();
-		}
-	}
 	async ensureSession(input) {
 		return await this.withEnsureSessionLock(input, async () => this.ensureSessionWithOwnership(input));
 	}
@@ -1116,27 +1074,28 @@ var AcpRuntimeManager = class {
 		try {
 			await client.start();
 			const session = await createOrLoadRuntimeSession(client, input.resumeSessionId, cwd);
-			const record = await this.createAndSaveRuntimeRecord({
+			const record = await this.prepareInitialRuntimeRecord({
 				input,
 				client,
+				owner,
 				agentCommand,
 				agentArgv,
 				cwd,
 				session
 			});
-			this.attachIdleProjection(owner, record);
 			await this.retainInitializedSessionOwner(owner, record);
 			retained = true;
 			return record;
 		} finally {
 			if (!retained) {
+				owner.recordId = void 0;
 				client.clearEventHandlers();
 				await client.close();
 			}
 		}
 	}
-	async createAndSaveRuntimeRecord(params) {
-		const { input, client, agentCommand, agentArgv, cwd, session } = params;
+	async prepareInitialRuntimeRecord(params) {
+		const { input, client, owner, agentCommand, agentArgv, cwd, session } = params;
 		const record = createInitialRecord({
 			recordId: createRecordId(input.sessionKey, input.mode),
 			sessionName: input.sessionKey,
@@ -1149,6 +1108,7 @@ var AcpRuntimeManager = class {
 		this.closingActiveRecords.delete(record.acpxRecordId);
 		record.protocolVersion = client.initializeResult?.protocolVersion;
 		record.agentCapabilities = client.initializeResult?.agentCapabilities;
+		this.attachIdleProjection(owner, record);
 		applyConfigOptionsToRecord(record, session.sessionResult);
 		const modelApplication = await applyRequestedModelIfAdvertised({
 			client,
@@ -1163,11 +1123,11 @@ var AcpRuntimeManager = class {
 		if (modelApplication.applied) setCurrentModelId(record, currentModelIdFromSetModelResponse(modelApplication.response, input.sessionOptions?.model));
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		persistSessionOptions(record, input.sessionOptions);
-		await this.options.sessionStore.save(record);
 		return record;
 	}
 	async retainInitializedSessionOwner(owner, record) {
 		owner.recordId = record.acpxRecordId;
+		await owner.projection?.checkpoint.checkpoint();
 		const previousOwner = this.retainedSessionOwners.get(record.acpxRecordId);
 		this.retainedSessionOwners.set(record.acpxRecordId, owner);
 		if (owner.mode === "oneshot") this.pendingOneShotRecordIds.set(owner.sessionKey, record.acpxRecordId);
@@ -1304,7 +1264,7 @@ var AcpRuntimeManager = class {
 				timeoutMs: task.input.timeoutMs ?? this.options.timeoutMs,
 				conversation: turn.conversation,
 				promptMessageId: turn.promptMessageId,
-				onPromptRequestStarted: () => task.promptStarted.resolve(),
+				onPromptRequestWritten: () => task.promptStarted.resolve(),
 				onElicitation: task.input.onElicitation
 			});
 		} finally {
@@ -1326,7 +1286,7 @@ var AcpRuntimeManager = class {
 				acpxState,
 				client,
 				owner,
-				pendingClient: retainedOwner?.client,
+				connected: retainedOwner !== void 0,
 				promptMessageId
 			});
 			this.activateRuntimeTurn(task, turn);
@@ -1387,7 +1347,7 @@ var AcpRuntimeManager = class {
 		});
 	}
 	createRunningRuntimeTurn(input) {
-		const { record, conversation, acpxState, client, owner, pendingClient, promptMessageId } = input;
+		const { record, conversation, acpxState, client, owner, connected, promptMessageId } = input;
 		const turn = {
 			record,
 			conversation,
@@ -1395,8 +1355,7 @@ var AcpRuntimeManager = class {
 			liveCheckpoint: this.createRuntimeTurnCheckpoint(record, conversation, () => turn.acpxState),
 			client,
 			owner,
-			pendingClient,
-			connectionUpdates: pendingClient ? void 0 : [],
+			connected,
 			promptMessageId,
 			activeSessionId: record.acpSessionId
 		};
@@ -1455,15 +1414,7 @@ var AcpRuntimeManager = class {
 				await this.waitForRuntimeControlSession(task, turn);
 				const models = advertisedModelState(turn.acpxState);
 				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models);
-				applyConfigOptionResponseToTurn(turn, response);
-				const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
-				nextState.session_options = {
-					...nextState.session_options,
-					model: modelId
-				};
-				nextState.current_model_id = currentModelIdFromSetModelResponse(response, modelId);
-				clearDesiredConfigOption(nextState, models?.configId);
-				turn.acpxState = nextState;
+				turn.acpxState = applyModelSelection(turn.acpxState, modelId, response);
 				return response;
 			},
 			setSessionConfigOption: async (configId, value) => {
@@ -1488,38 +1439,29 @@ 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);
-		this.applyRuntimeConfigOptionState(turn, resolvedConfigId, value, response);
+		turn.acpxState = applyConfigOptionSelection(turn.acpxState, resolvedConfigId, value, response, modelConfigId);
 		return {
 			configId: resolvedConfigId,
 			response
 		};
 	}
-	applyRuntimeConfigOptionState(turn, configId, value, response) {
-		applyConfigOptionResponseToTurn(turn, response);
-		applyDesiredConfigOptionToTurn(turn, configId, value);
-	}
 	emitRuntimeTurnEvent(task, payload) {
 		const parsed = parsePromptEventLine(JSON.stringify(payload));
 		if (!parsed) return;
 		task.queue.push(parsed);
 	}
 	async connectRuntimeTurn(task, turn) {
-		const loaded = turn.pendingClient ? {
+		if (turn.connected) return {
 			sessionId: turn.record.acpSessionId,
 			resumed: false,
 			loadError: void 0
-		} : await this.connectRuntimeTurnClient(task, turn);
-		this.drainRuntimeConnectionUpdates(turn);
-		return loaded;
-	}
-	drainRuntimeConnectionUpdates(turn) {
-		if (!turn.connectionUpdates) return;
+		};
+		const loaded = await this.connectRuntimeTurnClient(task, turn);
 		turn.acpxState = cloneSessionAcpxState(turn.record.acpx);
-		for (const notification of turn.connectionUpdates) turn.acpxState = recordSessionUpdate(turn.conversation, turn.acpxState, notification);
-		turn.connectionUpdates = void 0;
-		trimConversationForRuntime(turn.conversation);
-		turn.liveCheckpoint.request();
+		turn.connected = true;
+		return loaded;
 	}
 	async connectRuntimeTurnClient(task, turn) {
 		return await connectAndLoadSession({
@@ -1629,7 +1571,7 @@ var AcpRuntimeManager = class {
 		task.queue.close();
 	}
 	async finalizeRuntimeTurnRecord(turn) {
-		this.drainRuntimeConnectionUpdates(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);
@@ -1637,7 +1579,7 @@ var AcpRuntimeManager = class {
 		await turn.liveCheckpoint.flush();
 		const closed = await this.refreshClosedState(turn.record);
 		await this.options.sessionStore.save(turn.record);
-		if (closed) return false;
+		if (closed || !turn.connected) return false;
 		return await this.retainPersistentSessionOwnerAfterTurn({
 			record: turn.record,
 			owner: turn.owner,
@@ -1688,24 +1630,29 @@ var AcpRuntimeManager = class {
 	}
 	async setConfigOption(handle, key, value, sessionMode = "persistent") {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		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));
 	}
 	async setConfigOptionWithOwnership(handle, key, value, sessionMode) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
 			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value);
-			applyConfigOptionsToRecord(record, response);
-			applyDesiredConfigOptionToRecord(record, configId, value);
+			record.acpx = applyConfigOptionSelection(record.acpx, configId, value, response);
 			await this.options.sessionStore.save(record);
-			return;
+			return response;
 		}
 		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));
-			applyDesiredConfigOptionToRecord(connectedRecord, configId, value);
+			const modelConfigId = advertisedModelState(connectedRecord.acpx)?.configId;
+			const response = await client.setSessionConfigOption(sessionId, configId, value);
+			connectedRecord.acpx = applyConfigOptionSelection(connectedRecord.acpx, configId, value, response, modelConfigId);
+			return response;
+		}, {
+			key,
+			resolve: (connectedRecord) => resolveSupportedConfigOptionId(connectedRecord, key)
 		});
 		await this.options.sessionStore.save(result.record);
+		return result.value;
 	}
 	async cancel(handle) {
 		await this.activeControllers.get(handle.acpxRecordId ?? handle.sessionKey)?.requestCancelActivePrompt();
@@ -2117,7 +2064,7 @@ var AcpxRuntime = class {
 	}
 	async setConfigOption(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		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);
 	}
 	async cancel(input) {
 		const { handle } = this.resolveManagerHandle(input.handle);