acpx 0.13.1 → 0.13.2

package/dist/runtime.d.ts

@@ -1,7 +1,7 @@
 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 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";
 //#endregion
@@ -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?: {
@@ -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;

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-Gw2oGjhe.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);
@@ -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);