acpx 0.9.0 → 0.11.0

package/dist/{output-DPg20dvn.js → output-D_BGt1YI.js}

@@ -1,10 +1,10 @@
-import { $ as getPerfMetricsSnapshot, A as parsePromptStopReason, B as normalizeName, Bt as QueueProtocolError, C as applyConversation, Ct as formatErrorMessage, D as extractSessionUpdateNotification, E as AcpClient, F as findSession, H as resolveSessionRecord, I as findSessionByDirectoryWalk, J as sessionEventActivePath, K as defaultSessionEventLog, L as isoNow, Mt as OUTPUT_ERROR_CODES, N as absolutePath, Nt as OUTPUT_ERROR_ORIGINS, O as isAcpJsonRpcMessage, Ot as toAcpErrorPayload, P as findGitRepositoryRoot, Q as formatPerfMetric, R as listSessions, S as sessionOptionsFromRecord, Tt as normalizeOutputError, U as writeSessionRecord, V as pruneSessions, X as sessionEventSegmentPath, Y as sessionEventLockPath, _ as recordPromptSubmission, _t as withTimeout, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as mergeSessionOptions, c as setDesiredConfigOption, d as syncAdvertisedModelState, et as incrementPerfCounter, f as applyConfigOptionsToRecord, ft as promptToDisplayText, g as recordClientOperation, gt as withInterrupt, h as createSessionConversation, ht as TimeoutError, i as connectAndLoadSession, it as setPerfGauge, k as parseJsonRpcErrorMessage, l as setDesiredModeId, lt as isPromptInput, m as cloneSessionConversation, mt as InterruptedError, n as runPromptTurn, nt as recordPerfDuration, o as assertRequestedModelSupported, p as cloneSessionAcpxState, pt as textPrompt, q as sessionBaseDir, r as withConnectedSession, rt as resetPerfMetrics, s as setCurrentModelId, st as normalizeRuntimeSessionId, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModelId, v as recordSessionUpdate, w as applyLifecycleSnapshotToRecord, wt as isRetryablePromptError, x as persistSessionOptions, y as trimConversationForRuntime, z as listSessionsForAgent, zt as QueueConnectionError } from "./live-checkpoint-D5d-K9s1.js";
+import { $ as setPerfGauge, A as assertRequestedModelSupported, At as isRetryablePromptError, B as listSessions, C as mergeSessionOptions, Ct as withTimeout, D as applyLifecycleSnapshotToRecord, E as applyConversation, F as absolutePath, G as writeSessionRecord, H as normalizeName, I as findGitRepositoryRoot, J as getPerfMetricsSnapshot, Kt as QueueConnectionError, L as findSession, Pt as toAcpErrorPayload, Q as resetPerfMetrics, R as findSessionByDirectoryWalk, Rt as OUTPUT_ERROR_CODES, S as advertisedModelState, St as withInterrupt, T as sessionOptionsFromRecord, U as pruneSessions, V as listSessionsForAgent, W as resolveSessionRecord, X as measurePerf, Y as incrementPerfCounter, Z as recordPerfDuration, _ as createSessionConversation, a as applyRequestedModelIfAdvertised, at as defaultSessionEventLog, b as recordSessionUpdate, bt as InterruptedError, c as setCurrentModelId, ct as sessionEventLockPath, d as setDesiredModelId, dt as isAcpJsonRpcMessage, et as startPerfTimer, f as syncAdvertisedModelState, ft as parseJsonRpcErrorMessage, g as cloneSessionConversation, h as cloneSessionAcpxState, ht as isPromptInput, i as connectAndLoadSession, j as modelStateFromConfigOptions, jt as normalizeOutputError, k as AcpClient, kt as formatErrorMessage, l as setDesiredConfigOption, lt as sessionEventSegmentPath, m as applyConfigOptionsToState, n as runPromptTurn, o as currentModelIdFromSetModelResponse, ot as sessionBaseDir, p as applyConfigOptionsToRecord, pt as parsePromptStopReason, q as formatPerfMetric, qt as QueueProtocolError, r as withConnectedSession, rt as normalizeRuntimeSessionId, s as clearDesiredConfigOption, st as sessionEventActivePath, t as LiveSessionCheckpoint, u as setDesiredModeId, ut as extractSessionUpdateNotification, v as recordClientOperation, vt as promptToDisplayText, w as persistSessionOptions, x as trimConversationForRuntime, xt as TimeoutError, y as recordPromptSubmission, yt as textPrompt, z as isoNow, zt as OUTPUT_ERROR_ORIGINS } from "./live-checkpoint-BZrk9Mjz.js";
 import fs, { realpathSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
-import { spawn } from "node:child_process";
 import { createHash, randomInt, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 import net from "node:net";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -18,14 +18,6 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region src/cli/session/contracts.ts
-const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
-function normalizeQueueOwnerTtlMs(ttlMs) {
-	if (ttlMs == null) return DEFAULT_QUEUE_OWNER_TTL_MS;
-	if (!Number.isFinite(ttlMs) || ttlMs < 0) return DEFAULT_QUEUE_OWNER_TTL_MS;
-	return Math.round(ttlMs);
-}
-//#endregion
 //#region src/process-liveness.ts
 function isProcessAlive(pid) {
 	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
@@ -37,6 +29,14 @@ function isProcessAlive(pid) {
 	}
 }
 //#endregion
+//#region src/cli/session/contracts.ts
+const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
+function normalizeQueueOwnerTtlMs(ttlMs) {
+	if (ttlMs == null) return DEFAULT_QUEUE_OWNER_TTL_MS;
+	if (!Number.isFinite(ttlMs) || ttlMs < 0) return DEFAULT_QUEUE_OWNER_TTL_MS;
+	return Math.round(ttlMs);
+}
+//#endregion
 //#region src/cli/queue/paths.ts
 function shortHash(value, length) {
 	return createHash("sha256").update(value).digest("hex").slice(0, length);
@@ -617,7 +617,7 @@ const QUEUE_OWNER_MESSAGE_PARSERS = {
 	cancel_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "cancel_result", "cancelled"),
 	close_session_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "close_session_result", "closed"),
 	set_mode_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_mode_result", "modeId"),
-	set_model_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_model_result", "modelId"),
+	set_model_result: parseSetModelOwnerMessage,
 	set_config_option_result: parseSetConfigOptionOwnerMessage,
 	error: parseErrorOwnerMessage
 };
@@ -665,6 +665,17 @@ function parseStringResultOwnerMessage(message, context, type, field) {
 		[field]: message[field]
 	};
 }
+function parseSetModelOwnerMessage(message, context) {
+	if (typeof message.modelId !== "string") return null;
+	const response = asRecord$2(message.response);
+	if (message.response !== void 0 && (!response || !Array.isArray(response.configOptions))) return null;
+	return {
+		type: "set_model_result",
+		...context,
+		modelId: message.modelId,
+		...response ? { response } : {}
+	};
+}
 function parseSetConfigOptionOwnerMessage(message, context) {
 	const response = asRecord$2(message.response);
 	if (!response || !Array.isArray(response.configOptions)) return null;
@@ -919,11 +930,12 @@ var SessionQueueOwner = class SessionQueueOwner {
 				socket,
 				requestId: request.requestId,
 				run: async () => {
-					await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+					const response = await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
 					return {
 						type: "set_model_result",
 						requestId: request.requestId,
-						modelId: request.modelId
+						modelId: request.modelId,
+						response
 					};
 				}
 			});
@@ -1344,7 +1356,7 @@ async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
 		origin: "queue",
 		retryable: true
 	});
-	return true;
+	return response;
 }
 async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
 	const request = {
@@ -1453,9 +1465,10 @@ async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
 async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
 	const owner = await readQueueOwnerRecord(sessionId);
 	if (!owner) return;
-	if (await submitSetModelToQueueOwner(owner, modelId, timeoutMs)) {
-		if (verbose) process.stderr.write(`[acpx] requested session/set_model on owner pid ${owner.pid} for session ${sessionId}\n`);
-		return true;
+	const submitted = await submitSetModelToQueueOwner(owner, modelId, timeoutMs);
+	if (submitted) {
+		if (verbose) process.stderr.write(`[acpx] requested a model config update on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return submitted;
 	}
 	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
 	throw new QueueConnectionError("Session queue owner is running but not accepting set_model requests", {
@@ -1514,16 +1527,28 @@ async function runSessionSetModeDirect(options) {
 	})));
 }
 async function runSessionSetModelDirect(options) {
-	return toSessionMutationResult(await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
-		await withTimeout(client.setSessionModel(sessionId, options.modelId), options.timeoutMs);
-		setDesiredModelId(record, options.modelId);
-		setCurrentModelId(record, options.modelId);
-	})));
+	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const models = advertisedModelState(record.acpx);
+		const response = await withTimeout(client.setSessionModel(sessionId, options.modelId, models), options.timeoutMs);
+		applyConfigOptionsToRecord(record, response);
+		setDesiredModelId(record, options.modelId, models?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.modelId));
+		return response;
+	}));
+	return {
+		...toSessionMutationResult(result),
+		response: result.value
+	};
 }
 async function runSessionSetConfigOptionDirect(options) {
 	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
 		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value), options.timeoutMs);
-		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		applyConfigOptionsToRecord(record, response);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.value));
+		} else if (options.configId === "mode") setDesiredModeId(record, options.value);
 		else setDesiredConfigOption(record, options.configId, options.value);
 		return response;
 	}));
@@ -1566,13 +1591,16 @@ async function setSessionMode(options) {
 	});
 }
 async function setSessionModel(options) {
-	if (await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose)) {
+	const submittedToOwner = await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose);
+	if (submittedToOwner) {
 		const record = await resolveSessionRecord(options.sessionId);
-		setDesiredModelId(record, options.modelId);
-		setCurrentModelId(record, options.modelId);
+		applyConfigOptionsToRecord(record, submittedToOwner.response);
+		setDesiredModelId(record, options.modelId, advertisedModelState(record.acpx)?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(submittedToOwner.response, options.modelId));
 		await writeSessionRecord(record);
 		return {
 			record,
+			response: submittedToOwner.response,
 			resumed: false
 		};
 	}
@@ -1592,7 +1620,12 @@ async function setSessionConfigOption(options) {
 	const ownerResponse = await trySetConfigOptionOnRunningOwner(options.sessionId, options.configId, options.value, options.timeoutMs, options.verbose);
 	if (ownerResponse) {
 		const record = await resolveSessionRecord(options.sessionId);
-		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
+		applyConfigOptionsToRecord(record, ownerResponse);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(ownerResponse, options.value));
+		} else if (options.configId === "mode") setDesiredModeId(record, options.value);
 		else setDesiredConfigOption(record, options.configId, options.value);
 		await writeSessionRecord(record);
 		return {
@@ -1650,33 +1683,8 @@ async function closeSession(sessionId) {
 async function createSessionRecordWithClient(client, options) {
 	const cwd = absolutePath(options.cwd);
 	await withTimeout(client.start(), options.timeoutMs);
-	let sessionId;
-	let agentSessionId;
-	let sessionResult;
-	let sessionModels;
-	let requestedModelApplied = false;
-	if (options.resumeSessionId) {
-		const resumed = await resumeSessionRecordWithClient(client, options, cwd);
-		sessionId = resumed.sessionId;
-		agentSessionId = resumed.agentSessionId;
-		sessionResult = resumed.sessionResult;
-		sessionModels = resumed.sessionModels;
-		requestedModelApplied = resumed.requestedModelApplied;
-	} else {
-		const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
-		sessionId = createdSession.sessionId;
-		agentSessionId = normalizeRuntimeSessionId(createdSession.agentSessionId);
-		sessionResult = createdSession;
-		sessionModels = createdSession.models;
-		requestedModelApplied = await applyRequestedModelIfAdvertised({
-			client,
-			sessionId,
-			requestedModel: options.sessionOptions?.model,
-			models: sessionModels,
-			agentCommand: options.agentCommand,
-			timeoutMs: options.timeoutMs
-		});
-	}
+	const createdState = options.resumeSessionId ? await resumeSessionRecordWithClient(client, options, cwd) : await createFreshSessionState(client, options, cwd);
+	const { sessionId, agentSessionId } = createdState;
 	const lifecycle = client.getAgentLifecycleSnapshot();
 	const now = isoNow();
 	const record = {
@@ -1702,12 +1710,36 @@ async function createSessionRecordWithClient(client, options) {
 		acpx: {}
 	};
 	persistSessionOptions(record, options.sessionOptions);
-	applyConfigOptionsToRecord(record, sessionResult);
-	syncAdvertisedModelState(record, sessionModels);
-	if (requestedModelApplied) setCurrentModelId(record, options.sessionOptions?.model);
+	applyCreatedSessionModelState(record, createdState, options.sessionOptions?.model);
 	await writeSessionRecord(record);
 	return record;
 }
+function applyCreatedSessionModelState(record, state, requestedModel) {
+	applyConfigOptionsToRecord(record, state.sessionResult);
+	applyConfigOptionsToRecord(record, state.requestedModelResponse);
+	syncAdvertisedModelState(record, state.requestedModelResponse ? modelStateFromConfigOptions(state.requestedModelResponse.configOptions) : state.sessionModels);
+	if (state.requestedModelApplied) setCurrentModelId(record, currentModelIdFromSetModelResponse(state.requestedModelResponse, requestedModel));
+}
+async function createFreshSessionState(client, options, cwd) {
+	const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
+	const modelApplication = await applyRequestedModelIfAdvertised({
+		client,
+		sessionId: createdSession.sessionId,
+		requestedModel: options.sessionOptions?.model,
+		models: createdSession.models,
+		agentCommand: options.agentCommand,
+		timeoutMs: options.timeoutMs,
+		onWarning: options.onModelWarning
+	});
+	return {
+		sessionId: createdSession.sessionId,
+		agentSessionId: normalizeRuntimeSessionId(createdSession.agentSessionId),
+		sessionResult: createdSession,
+		sessionModels: createdSession.models,
+		requestedModelApplied: modelApplication.applied,
+		requestedModelResponse: modelApplication.response
+	};
+}
 async function resumeSessionRecordWithClient(client, options, cwd) {
 	if (!options.resumeSessionId) throw new Error("resumeSessionId is required");
 	const resumeMethod = client.supportsResumeSession() ? "session/resume" : client.supportsLoadSession() ? "session/load" : void 0;
@@ -1715,19 +1747,22 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 	try {
 		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd) : client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
 		const sessionModels = resumedSession.models;
+		const modelApplication = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId: options.resumeSessionId,
+			requestedModel: options.sessionOptions?.model,
+			models: sessionModels,
+			agentCommand: options.agentCommand,
+			timeoutMs: options.timeoutMs,
+			onWarning: options.onModelWarning
+		});
 		return {
 			sessionId: options.resumeSessionId,
 			agentSessionId: normalizeRuntimeSessionId(resumedSession.agentSessionId),
 			sessionResult: resumedSession,
 			sessionModels,
-			requestedModelApplied: await applyRequestedModelIfAdvertised({
-				client,
-				sessionId: options.resumeSessionId,
-				requestedModel: options.sessionOptions?.model,
-				models: sessionModels,
-				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs
-			})
+			requestedModelApplied: modelApplication.applied,
+			requestedModelResponse: modelApplication.response
 		};
 	} catch (error) {
 		throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
@@ -2015,11 +2050,8 @@ var QueueOwnerTurnController = class {
 	async setSessionModel(modelId, timeoutMs) {
 		this.assertCanHandleControlRequest();
 		const activeController = this.activeController;
-		if (activeController) {
-			await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
-			return;
-		}
-		await this.options.setSessionModelFallback(modelId, timeoutMs);
+		if (activeController) return await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
+		return await this.options.setSessionModelFallback(modelId, timeoutMs);
 	}
 	async setSessionConfigOption(configId, value, timeoutMs) {
 		this.assertCanHandleControlRequest();
@@ -2379,35 +2411,54 @@ function toPromptResult(stopReason, sessionId, client) {
 function requestedModelId(value) {
 	return typeof value === "string" ? value.trim() : "";
 }
-function advertisedModelsForRecord(record) {
-	const availableModels = record.acpx?.available_models;
-	if (!Array.isArray(availableModels)) return;
-	return {
-		currentModelId: record.acpx?.current_model_id ?? "",
-		availableModels: availableModels.map((modelId) => ({
-			modelId,
-			name: modelId
-		}))
-	};
+function applyConfigOptionResponseToState(state, response) {
+	if (!response?.configOptions) return state;
+	return applyConfigOptionsToState(state, response.configOptions);
+}
+function mergeConnectedModelState(state, connectedState) {
+	if (!connectedState) return state;
+	const nextState = cloneSessionAcpxState(state) ?? {};
+	mergeConnectedAdvertisedModelState(nextState, connectedState);
+	mergeConnectedModelPreferences(nextState, connectedState);
+	return nextState;
+}
+function mergeConnectedAdvertisedModelState(nextState, connectedState) {
+	if (connectedState.config_options !== void 0) nextState.config_options = structuredClone(connectedState.config_options);
+	else delete nextState.config_options;
+	if (connectedState.current_model_id !== void 0) nextState.current_model_id = connectedState.current_model_id;
+	else delete nextState.current_model_id;
+	if (connectedState.available_models) nextState.available_models = [...connectedState.available_models];
+	else delete nextState.available_models;
+	if (connectedState.model_control) nextState.model_control = connectedState.model_control;
+	else delete nextState.model_control;
+}
+function mergeConnectedModelPreferences(nextState, connectedState) {
+	if (connectedState.session_options) nextState.session_options = cloneSessionAcpxState(connectedState)?.session_options;
+	if (connectedState.desired_mode_id !== void 0) nextState.desired_mode_id = connectedState.desired_mode_id;
+	if (connectedState.desired_config_options) nextState.desired_config_options = { ...connectedState.desired_config_options };
 }
 async function applyPromptModelIfAdvertised(params) {
 	const requestedModel = requestedModelId(params.requestedModel);
 	if (!requestedModel) return;
-	const models = advertisedModelsForRecord(params.record);
-	assertRequestedModelSupported({
+	const models = advertisedModelState(params.record.acpx);
+	emitModelSupportWarning(assertRequestedModelSupported({
 		requestedModel,
 		models,
 		agentCommand: params.record.agentCommand,
 		context: "apply"
-	});
+	}), params.suppressWarnings);
 	if (!models) return;
 	if (params.record.acpx?.current_model_id === requestedModel) {
-		setDesiredModelId(params.record, requestedModel);
+		setDesiredModelId(params.record, requestedModel, models.configId);
 		return;
 	}
-	await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel), params.timeoutMs);
-	setDesiredModelId(params.record, requestedModel);
-	setCurrentModelId(params.record, requestedModel);
+	const response = await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, models), params.timeoutMs);
+	applyConfigOptionsToRecord(params.record, response);
+	setDesiredModelId(params.record, requestedModel, models.configId);
+	setCurrentModelId(params.record, currentModelIdFromSetModelResponse(response, requestedModel));
+}
+function emitModelSupportWarning(warning, suppressWarnings) {
+	if (warning && !suppressWarnings) process.stderr.write(`[acpx] warning: ${warning}\n`);
 }
 function jsonRpcIdKey$1(value) {
 	if (typeof value === "string") return `s:${value}`;
@@ -2685,10 +2736,37 @@ async function runSessionPrompt(options) {
 			await client.setSessionMode(activeSessionIdForControl, modeId);
 		},
 		setSessionModel: async (modelId) => {
-			await client.setSessionModel(activeSessionIdForControl, modelId);
+			const models = advertisedModelState(acpxState);
+			const response = await client.setSessionModel(activeSessionIdForControl, modelId, models);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			nextState.session_options = {
+				...nextState.session_options,
+				model: modelId
+			};
+			nextState.current_model_id = currentModelIdFromSetModelResponse(response, modelId);
+			clearDesiredConfigOption(nextState, models?.configId);
+			acpxState = nextState;
+			return response;
 		},
 		setSessionConfigOption: async (configId, value) => {
-			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+			const response = await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			if (configId === modelStateFromConfigOptions(nextState.config_options)?.configId) {
+				nextState.session_options = {
+					...nextState.session_options,
+					model: value
+				};
+				nextState.current_model_id = currentModelIdFromSetModelResponse(response, value);
+				clearDesiredConfigOption(nextState, configId);
+			} else if (configId === "mode") nextState.desired_mode_id = value;
+			else nextState.desired_config_options = {
+				...nextState.desired_config_options,
+				[configId]: value
+			};
+			acpxState = nextState;
+			return response;
 		}
 	};
 	const flushConnectOutput = (loadError) => {
@@ -2707,6 +2785,7 @@ async function runSessionPrompt(options) {
 					resumePolicy: options.resumePolicy,
 					timeoutMs: options.timeoutMs,
 					verbose: options.verbose,
+					suppressWarnings: options.suppressSdkConsoleErrors,
 					activeController,
 					onClientAvailable: (controller) => {
 						options.onClientAvailable?.(controller);
@@ -2720,6 +2799,7 @@ async function runSessionPrompt(options) {
 					}
 				});
 			});
+			acpxState = mergeConnectedModelState(acpxState, record.acpx);
 			flushConnectOutput(connected.loadError);
 			emitConnectPerfMetric(connectStartedAt, options.verbose);
 			return connected;
@@ -2807,8 +2887,10 @@ async function runSessionPrompt(options) {
 				sessionId: activeSessionId,
 				requestedModel: sessionOptions?.model,
 				record,
-				timeoutMs: options.timeoutMs
+				timeoutMs: options.timeoutMs,
+				suppressWarnings: options.suppressSdkConsoleErrors
 			});
+			acpxState = cloneSessionAcpxState(record.acpx);
 			output.setContext({ sessionId: record.acpxRecordId });
 			await liveCheckpoint.checkpoint();
 			const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
@@ -2909,7 +2991,8 @@ async function runOnce(options) {
 				requestedModel: options.sessionOptions?.model,
 				models: createdSession.models,
 				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs
+				timeoutMs: options.timeoutMs,
+				onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 			});
 			output.setContext({ sessionId });
 			const response = await runExecPromptWithRetries(sessionId);
@@ -3001,7 +3084,7 @@ function createQueueOwnerTurnController(options) {
 			});
 		},
 		setSessionModelFallback: async (modelId, timeoutMs) => {
-			await runSessionSetModelDirect({
+			return (await runSessionSetModelDirect({
 				sessionRecordId: options.sessionId,
 				modelId,
 				mcpServers: options.mcpServers,
@@ -3011,7 +3094,7 @@ function createQueueOwnerTurnController(options) {
 				terminal: options.terminal,
 				timeoutMs,
 				verbose: options.verbose
-			});
+			})).response;
 		},
 		setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
 			return (await runSessionSetConfigOptionDirect({
@@ -3105,9 +3188,7 @@ async function runSessionQueueOwner(options) {
 			setSessionMode: async (modeId, timeoutMs) => {
 				await turnController.setSessionMode(modeId, timeoutMs);
 			},
-			setSessionModel: async (modelId, timeoutMs) => {
-				await turnController.setSessionModel(modelId, timeoutMs);
-			},
+			setSessionModel: async (modelId, timeoutMs) => await turnController.setSessionModel(modelId, timeoutMs),
 			setSessionConfigOption: async (configId, value, timeoutMs) => {
 				return await turnController.setSessionConfigOption(configId, value, timeoutMs);
 			}
@@ -3201,6 +3282,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	listAgentSessions: () => listAgentSessions,
 	listSessions: () => listSessions,
 	listSessionsForAgent: () => listSessionsForAgent,
+	mergeConnectedModelState: () => mergeConnectedModelState,
 	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
 	pruneSessions: () => pruneSessions,
 	runOnce: () => runOnce,
@@ -4141,6 +4223,6 @@ function createOutputFormatter(format, options = {}) {
 	}
 }
 //#endregion
-export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
+export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as g, isProcessAlive as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
 
-//# sourceMappingURL=output-DPg20dvn.js.map
+//# sourceMappingURL=output-D_BGt1YI.js.map