fengming 0.3.8 → 0.3.10

package/dist/agent-DLDIbUT4.js

@@ -0,0 +1,1825 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
+import { a as formatUncaughtError, c as readErrorName } from "./errors-C_Wa6a5T.js";
+import { n as isAbortError } from "./unhandled-rejections-CyXc0Srv.js";
+import { _ as uniqueStrings, l as normalizeStringEntries } from "./string-normalization-B8G0vlWE.js";
+import { n as defaultRuntime } from "./runtime-BkTkFkXs.js";
+import "./agent-scope-EEbMCF2I.js";
+import { a as isSubagentSessionKey, c as parseAgentSessionKey, l as parseRawSessionConversationRef, n as isAcpSessionKey, u as parseThreadSessionSuffix } from "./session-key-utils-CdfsDYvz.js";
+import { d as resolveAgentIdFromSessionKey, l as normalizeAgentId, o as classifySessionKeyShape } from "./session-key-CJf5_zWs.js";
+import { c as resolveDefaultAgentId, n as listAgentIds, o as resolveAgentWorkspaceDir } from "./agent-scope-config-BHdZonI2.js";
+import { r as resolveProviderIdForAuth } from "./provider-auth-aliases-hXKyFMus.js";
+import { a as hasGatewayClientCap, r as GATEWAY_CLIENT_MODES, t as GATEWAY_CLIENT_CAPS } from "./client-info-D6_UASoA.js";
+import { Ri as ErrorCodes, i as validateAgentWaitParams, n as validateAgentIdentityParams, r as validateAgentParams, t as formatValidationErrors, zi as errorShape } from "./src-B1Y482-m.js";
+import { a as isInternalNonDeliveryChannel } from "./message-channel-core-rOsWksPZ.js";
+import { i as normalizeMessageChannel, n as isGatewayMessageChannel, t as isDeliverableMessageChannel } from "./message-channel-normalize-CaOaCinb.js";
+import "./message-channel-DcN_7tYD.js";
+import { t as setSafeTimeout } from "./timer-delay-QZRLOpQs.js";
+import { t as ADMIN_SCOPE } from "./operator-scopes-DGvgHuOd.js";
+import "./method-scopes-CTk-6mpm.js";
+import { i as resolveAssistantAvatarUrl } from "./control-ui-shared-AfP1FlbS.js";
+import { l as onAgentEvent, u as registerAgentRunContext } from "./agent-events-Dl8p_DjC.js";
+import { n as resolveAgentMainSessionKey, r as resolveExplicitAgentSessionKey } from "./main-session-BxJmPEXx.js";
+import { i as resolveSessionStoreKey, n as canonicalizeSpawnedByForAgent } from "./session-store-key-dbCfepNe.js";
+import { i as mergeDeliveryContext, o as normalizeDeliveryContext, s as normalizeSessionDeliveryFields } from "./delivery-context.shared-CHlZnq4E.js";
+import { a as resolveSessionFilePathOptions, i as resolveSessionFilePath } from "./paths-C79m3Aob.js";
+import { T as resolveMaintenanceConfigFromInput } from "./store-load-CVdafI-Y.js";
+import { d as updateSessionStore } from "./store-DH20opqS.js";
+import { n as mergeSessionEntry } from "./types-D7s3-R_6.js";
+import "./sessions-CtMqsEs2.js";
+import { n as resolveSessionLifecycleTimestamps } from "./lifecycle-rFgZXsYo.js";
+import { c as resolveSessionResetPolicy, n as resolveChannelResetConfig, o as evaluateSessionFreshness, r as resolveSessionResetType } from "./reset-DxKwvg03.js";
+import { t as asBoolean } from "./boolean-CZag3-H2.js";
+import { r as resolveAgentTimeoutMs } from "./task-completion-contract-BqW0VJsk.js";
+import { a as normalizeAgentRunTimeoutPhase, i as mergeAgentRunTerminalOutcome, t as buildAgentRunTerminalOutcome } from "./agent-run-terminal-outcome-uM9dOCUm.js";
+import { i as createRunningTaskRun, o as finalizeTaskRunByRunId } from "./detached-task-runtime-C6Jx9d2V.js";
+import { c as shouldPreserveUserFacingSessionStateForInputProvenance, n as annotateInterSessionPromptText, s as normalizeInputProvenance } from "./input-provenance-DCrP7aPH.js";
+import { c as loadSessionEntry, l as migrateAndPruneGatewaySessionStoreKey, m as resolveGatewaySessionStoreTarget, p as resolveGatewayModelSupportsImages, s as loadGatewaySessionRow, v as resolveSessionModelRef } from "./session-utils-pgndLXV7.js";
+import { i as resolveSandboxConfigForAgent } from "./config-BT7xcTy8.js";
+import { o as isTimeoutError } from "./failover-error-77jtO3vs.js";
+import { s as resolveTrustedGroupId } from "./agent-tools.policy-CAz43ea3.js";
+import { i as resolveIngressWorkspaceOverrideForSpawnedRun, r as normalizeSpawnedRunMetadata } from "./spawn-requester-origin-Cx8MeOy5.js";
+import "./subagent-announce-delivery-CtmEvLTS.js";
+import { n as shouldDowngradeDeliveryToSessionOnly } from "./best-effort-delivery-B8Rfs1sR.js";
+import { n as resolveMessageChannelSelection } from "./channel-selection-YbyZhzrf.js";
+import { n as resolveSendPolicy } from "./send-policy-C6dhXszH.js";
+import { a as resolveAgentRunExpiresAtMs, i as registerChatAbortController, o as updateChatRunProvider } from "./chat-abort-wipQF0Ih.js";
+import { a as emitGatewaySessionEndPluginHook, c as performGatewaySessionReset, o as emitGatewaySessionStartPluginHook } from "./session-reset-service-BYbADY57.js";
+import { i as resolveBareSessionResetPromptState, n as shouldApplyStartupContext, r as resolveBareResetBootstrapFileAccess, t as buildSessionStartupContextPrelude } from "./startup-context-CZfmG8-g.js";
+import { n as resolvePublicAgentAvatarSource, t as resolveAgentAvatar } from "./identity-avatar-Cbsreyhk.js";
+import { n as agentCommandFromIngress } from "./agent-command-ppfDBwET.js";
+import { t as formatForLog } from "./ws-log-BzGc41ZC.js";
+import "./agent-1M2dVE2G.js";
+import { n as consumeExecApprovalFollowupRuntimeHandoff, r as parseExecApprovalFollowupApprovalId } from "./bash-tools.exec-approval-followup-state-CZKm2nN5.js";
+import { n as resolveAgentOutboundTarget, t as resolveAgentDeliveryPlanWithSessionRoute } from "./agent-delivery-DzK74C1L.js";
+import { a as resolveChatAttachmentMaxBytes, i as parseMessageWithAttachments, n as MediaOffloadError, t as normalizeRpcAttachmentsToChatAttachments } from "./attachment-normalize-Bb3v5iCC.js";
+import { n as timestampOptsFromConfig, t as injectTimestamp } from "./agent-timestamp-ClgiA1GA.js";
+import { n as setGatewayDedupeEntry, r as waitForTerminalGatewayDedupe, t as readTerminalSnapshotFromGatewayDedupe } from "./agent-wait-dedupe-I81_F2tr.js";
+import { n as resolveAssistantIdentity } from "./assistant-identity-Q4krpxtt.js";
+import { r as resolveVoiceWakeRouteByTrigger, t as loadVoiceWakeRoutingConfig } from "./voicewake-routing-Hlporigi.js";
+import { t as reactivateCompletedSubagentSession } from "./session-subagent-reactivation-CH0C2I6Y.js";
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/server-methods/agent-job.ts
+const AGENT_RUN_CACHE_TTL_MS = 10 * 6e4;
+/**
+* Embedded runs can emit transient lifecycle `error` events while auth/model
+* failover is still in progress. Give errors a short grace window so a
+* subsequent `start` event can cancel premature terminal snapshots.
+*/
+const AGENT_RUN_ERROR_RETRY_GRACE_MS = 15e3;
+/**
+* Some embedded runtimes emit an intermediate lifecycle `end` with
+* `aborted=true` immediately before retrying the same run. Hold timeout
+* snapshots briefly so `agent.wait` does not resolve to a stale timeout when a
+* final success is about to arrive.
+*/
+const AGENT_RUN_TIMEOUT_RETRY_GRACE_MS = 15e3;
+const agentRunCache = /* @__PURE__ */ new Map();
+const agentRunStarts = /* @__PURE__ */ new Map();
+const pendingAgentRunErrors = /* @__PURE__ */ new Map();
+const pendingAgentRunTimeouts = /* @__PURE__ */ new Map();
+const agentRunWaiterCounts = /* @__PURE__ */ new Map();
+let agentRunListenerStarted = false;
+function pruneAgentRunCache(now = Date.now()) {
+	for (const [runId, entry] of agentRunCache) if (now - entry.ts > AGENT_RUN_CACHE_TTL_MS) agentRunCache.delete(runId);
+}
+function recordAgentRunSnapshot(entry) {
+	pruneAgentRunCache(entry.ts);
+	const existing = agentRunCache.get(entry.runId);
+	if (existing && shouldPreserveTerminalSnapshot(existing, entry)) {
+		agentRunCache.set(entry.runId, {
+			...existing,
+			ts: entry.ts
+		});
+		return;
+	}
+	agentRunCache.set(entry.runId, entry);
+}
+function shouldPreserveTerminalSnapshot(existing, incoming) {
+	const existingOutcome = terminalOutcomeFromSnapshot(existing);
+	const incomingOutcome = terminalOutcomeFromSnapshot(incoming);
+	if (!existingOutcome) return false;
+	if (!incomingOutcome) return false;
+	return mergeAgentRunTerminalOutcome(existingOutcome, incomingOutcome) === existingOutcome;
+}
+function terminalOutcomeFromSnapshot(snapshot) {
+	if (snapshot.pendingError) return;
+	return buildAgentRunTerminalOutcome(snapshot);
+}
+function clearPendingAgentRunError(runId) {
+	const pending = pendingAgentRunErrors.get(runId);
+	if (!pending) return;
+	clearTimeout(pending.timer);
+	pendingAgentRunErrors.delete(runId);
+}
+function clearPendingAgentRunTimeout(runId) {
+	const pending = pendingAgentRunTimeouts.get(runId);
+	if (!pending) return;
+	clearTimeout(pending.timer);
+	pendingAgentRunTimeouts.delete(runId);
+}
+function schedulePendingAgentRunError(snapshot) {
+	const pendingTimeout = pendingAgentRunTimeouts.get(snapshot.runId);
+	if (pendingTimeout && shouldPreserveTerminalSnapshot(pendingTimeout.snapshot, snapshot)) return;
+	clearPendingAgentRunTimeout(snapshot.runId);
+	clearPendingAgentRunError(snapshot.runId);
+	const dueAt = Date.now() + AGENT_RUN_ERROR_RETRY_GRACE_MS;
+	const timer = setTimeout(() => {
+		const pending = pendingAgentRunErrors.get(snapshot.runId);
+		if (!pending) return;
+		pendingAgentRunErrors.delete(snapshot.runId);
+		recordAgentRunSnapshot(pending.snapshot);
+	}, AGENT_RUN_ERROR_RETRY_GRACE_MS);
+	timer.unref?.();
+	pendingAgentRunErrors.set(snapshot.runId, {
+		snapshot,
+		dueAt,
+		timer
+	});
+}
+function schedulePendingAgentRunTimeout(snapshot) {
+	const pendingTimeout = pendingAgentRunTimeouts.get(snapshot.runId);
+	if (pendingTimeout && shouldPreserveTerminalSnapshot(pendingTimeout.snapshot, snapshot)) return;
+	clearPendingAgentRunError(snapshot.runId);
+	clearPendingAgentRunTimeout(snapshot.runId);
+	const dueAt = Date.now() + AGENT_RUN_TIMEOUT_RETRY_GRACE_MS;
+	const timer = setTimeout(() => {
+		const pending = pendingAgentRunTimeouts.get(snapshot.runId);
+		if (!pending) return;
+		pendingAgentRunTimeouts.delete(snapshot.runId);
+		recordAgentRunSnapshot(pending.snapshot);
+	}, AGENT_RUN_TIMEOUT_RETRY_GRACE_MS);
+	timer.unref?.();
+	pendingAgentRunTimeouts.set(snapshot.runId, {
+		snapshot,
+		dueAt,
+		timer
+	});
+}
+function getPendingAgentRunError(runId) {
+	const pending = pendingAgentRunErrors.get(runId);
+	if (!pending) return;
+	return {
+		snapshot: pending.snapshot,
+		dueAt: pending.dueAt
+	};
+}
+function getPendingAgentRunTimeout(runId) {
+	const pending = pendingAgentRunTimeouts.get(runId);
+	if (!pending) return;
+	return {
+		snapshot: pending.snapshot,
+		dueAt: pending.dueAt
+	};
+}
+function createPendingErrorTimeoutSnapshot(snapshot) {
+	return {
+		runId: snapshot.runId,
+		status: "timeout",
+		startedAt: snapshot.startedAt,
+		error: snapshot.error,
+		pendingError: true,
+		...snapshot.providerStarted !== void 0 ? { providerStarted: snapshot.providerStarted } : {},
+		ts: Date.now()
+	};
+}
+function createSnapshotFromLifecycleEvent(params) {
+	const { runId, phase, data } = params;
+	const startedAt = typeof data?.startedAt === "number" ? data.startedAt : agentRunStarts.get(runId);
+	const endedAt = typeof data?.endedAt === "number" ? data.endedAt : void 0;
+	const error = typeof data?.error === "string" ? data.error : void 0;
+	const stopReason = typeof data?.stopReason === "string" ? data.stopReason : void 0;
+	const livenessState = typeof data?.livenessState === "string" ? data.livenessState : void 0;
+	const terminalOutcome = buildAgentRunTerminalOutcome({
+		status: phase === "error" ? "error" : data?.aborted ? "timeout" : "ok",
+		error,
+		stopReason,
+		livenessState,
+		timeoutPhase: data?.timeoutPhase,
+		providerStarted: data?.providerStarted,
+		startedAt,
+		endedAt
+	});
+	return {
+		runId,
+		status: terminalOutcome.status,
+		startedAt,
+		endedAt,
+		error: terminalOutcome.error,
+		stopReason,
+		livenessState,
+		...data?.yielded === true ? { yielded: true } : {},
+		...terminalOutcome.timeoutPhase ? { timeoutPhase: terminalOutcome.timeoutPhase } : {},
+		...terminalOutcome.providerStarted !== void 0 ? { providerStarted: terminalOutcome.providerStarted } : {},
+		ts: Date.now()
+	};
+}
+function ensureAgentRunListener() {
+	if (agentRunListenerStarted) return;
+	agentRunListenerStarted = true;
+	onAgentEvent((evt) => {
+		if (!evt) return;
+		if (evt.stream !== "lifecycle") return;
+		const phase = evt.data?.phase;
+		if (phase === "start") {
+			const startedAt = typeof evt.data?.startedAt === "number" ? evt.data.startedAt : void 0;
+			agentRunStarts.set(evt.runId, startedAt ?? Date.now());
+			clearPendingAgentRunError(evt.runId);
+			clearPendingAgentRunTimeout(evt.runId);
+			agentRunCache.delete(evt.runId);
+			return;
+		}
+		if (phase !== "end" && phase !== "error") return;
+		const snapshot = createSnapshotFromLifecycleEvent({
+			runId: evt.runId,
+			phase,
+			data: evt.data
+		});
+		agentRunStarts.delete(evt.runId);
+		if (phase === "error") {
+			schedulePendingAgentRunError(snapshot);
+			return;
+		}
+		if (snapshot.status === "timeout") {
+			schedulePendingAgentRunTimeout(snapshot);
+			return;
+		}
+		const pendingTimeout = pendingAgentRunTimeouts.get(evt.runId);
+		if (pendingTimeout && shouldPreserveTerminalSnapshot(pendingTimeout.snapshot, snapshot)) return;
+		clearPendingAgentRunError(evt.runId);
+		clearPendingAgentRunTimeout(evt.runId);
+		recordAgentRunSnapshot(snapshot);
+	});
+}
+function getCachedAgentRun(runId) {
+	pruneAgentRunCache();
+	return agentRunCache.get(runId);
+}
+function addAgentRunWaiter(runId) {
+	agentRunWaiterCounts.set(runId, (agentRunWaiterCounts.get(runId) ?? 0) + 1);
+	let removed = false;
+	return () => {
+		if (removed) return;
+		removed = true;
+		const nextCount = (agentRunWaiterCounts.get(runId) ?? 1) - 1;
+		if (nextCount <= 0) {
+			agentRunWaiterCounts.delete(runId);
+			return;
+		}
+		agentRunWaiterCounts.set(runId, nextCount);
+	};
+}
+async function waitForAgentJob(params) {
+	const { runId, timeoutMs, signal, ignoreCachedSnapshot = false } = params;
+	ensureAgentRunListener();
+	const cached = ignoreCachedSnapshot ? void 0 : getCachedAgentRun(runId);
+	if (cached) return cached;
+	if (timeoutMs <= 0 || signal?.aborted) return null;
+	return await new Promise((resolve) => {
+		let settled = false;
+		let pendingErrorTimer;
+		let pendingTimeoutTimer;
+		let pendingTimeoutSnapshot;
+		let onAbort;
+		let removeWaiter = () => {};
+		const clearPendingErrorTimer = () => {
+			if (!pendingErrorTimer) return;
+			clearTimeout(pendingErrorTimer);
+			pendingErrorTimer = void 0;
+		};
+		const clearPendingTimeoutTimer = () => {
+			if (!pendingTimeoutTimer) return;
+			clearTimeout(pendingTimeoutTimer);
+			pendingTimeoutTimer = void 0;
+			pendingTimeoutSnapshot = void 0;
+		};
+		const finish = (entry) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			clearPendingErrorTimer();
+			clearPendingTimeoutTimer();
+			unsubscribe();
+			removeWaiter();
+			if (onAbort) signal?.removeEventListener("abort", onAbort);
+			resolve(entry);
+		};
+		const scheduleTerminalFinish = (kind, snapshot, delayMs) => {
+			if (pendingTimeoutSnapshot && shouldPreserveTerminalSnapshot(pendingTimeoutSnapshot, snapshot)) return;
+			clearPendingErrorTimer();
+			clearPendingTimeoutTimer();
+			const timerRef = setSafeTimeout(() => {
+				const latest = ignoreCachedSnapshot ? void 0 : getCachedAgentRun(runId);
+				if (latest) {
+					finish(latest);
+					return;
+				}
+				recordAgentRunSnapshot(snapshot);
+				finish(snapshot);
+			}, delayMs);
+			timerRef.unref?.();
+			if (kind === "error") pendingErrorTimer = timerRef;
+			else {
+				pendingTimeoutTimer = timerRef;
+				pendingTimeoutSnapshot = snapshot;
+			}
+		};
+		const scheduleErrorFinish = (snapshot, delayMs = AGENT_RUN_ERROR_RETRY_GRACE_MS) => {
+			scheduleTerminalFinish("error", snapshot, delayMs);
+		};
+		const scheduleTimeoutFinish = (snapshot, delayMs = AGENT_RUN_TIMEOUT_RETRY_GRACE_MS) => {
+			scheduleTerminalFinish("timeout", snapshot, delayMs);
+		};
+		if (!ignoreCachedSnapshot) {
+			const pendingError = getPendingAgentRunError(runId);
+			if (pendingError) scheduleErrorFinish(pendingError.snapshot, pendingError.dueAt - Date.now());
+			const pendingTimeout = getPendingAgentRunTimeout(runId);
+			if (pendingTimeout) scheduleTimeoutFinish(pendingTimeout.snapshot, pendingTimeout.dueAt - Date.now());
+		}
+		const unsubscribe = onAgentEvent((evt) => {
+			if (!evt || evt.stream !== "lifecycle") return;
+			if (evt.runId !== runId) return;
+			const phase = evt.data?.phase;
+			if (phase === "start") {
+				clearPendingErrorTimer();
+				clearPendingTimeoutTimer();
+				return;
+			}
+			if (phase !== "end" && phase !== "error") return;
+			const latest = ignoreCachedSnapshot ? void 0 : getCachedAgentRun(runId);
+			if (latest) {
+				if (pendingTimeoutSnapshot && shouldPreserveTerminalSnapshot(pendingTimeoutSnapshot, latest)) return;
+				finish(latest);
+				return;
+			}
+			const snapshot = createSnapshotFromLifecycleEvent({
+				runId: evt.runId,
+				phase,
+				data: evt.data
+			});
+			if (phase === "error") {
+				scheduleErrorFinish(snapshot);
+				return;
+			}
+			if (snapshot.status === "timeout") {
+				scheduleTimeoutFinish(snapshot);
+				return;
+			}
+			if (pendingTimeoutSnapshot && shouldPreserveTerminalSnapshot(pendingTimeoutSnapshot, snapshot)) return;
+			recordAgentRunSnapshot(snapshot);
+			finish(snapshot);
+		});
+		removeWaiter = addAgentRunWaiter(runId);
+		const timer = setSafeTimeout(() => {
+			const pendingError = getPendingAgentRunError(runId);
+			finish(pendingError ? createPendingErrorTimeoutSnapshot(pendingError.snapshot) : null);
+		}, timeoutMs);
+		onAbort = () => finish(null);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+ensureAgentRunListener();
+//#endregion
+//#region src/gateway/server-methods/agent.ts
+const RESET_COMMAND_RE = /^\/(new|reset)(?:\s+([\s\S]*))?$/i;
+function formatAttachmentFailureForLog(err) {
+	const primary = formatUncaughtError(err);
+	const cause = err instanceof Error ? err.cause : void 0;
+	if (cause === void 0) return primary;
+	const causeText = formatUncaughtError(cause);
+	if (!causeText || causeText === primary) return primary;
+	return `${primary}\nCaused by: ${causeText}`;
+}
+function logAttachmentFailure(logGateway, label, err) {
+	logGateway.error(label, {
+		error: formatAttachmentFailureForLog(err),
+		consoleMessage: `${label}: ${formatForLog(err)}`
+	});
+}
+function clientHasAdminScope(client) {
+	return (Array.isArray(client?.connect?.scopes) ? client.connect.scopes : []).includes(ADMIN_SCOPE);
+}
+function resolveAllowModelOverrideFromClient(client) {
+	return clientHasAdminScope(client) || client?.internal?.allowModelOverride === true;
+}
+function resolveCanResetSessionFromClient(client) {
+	return clientHasAdminScope(client);
+}
+function resolveCanUseInternalRuntimeHandoff(client) {
+	return client?.connect?.client?.mode === GATEWAY_CLIENT_MODES.BACKEND;
+}
+function emitAgentSendSessionLifecycleTransition(transition) {
+	if (!transition) return;
+	if (transition.previousSessionId) emitGatewaySessionEndPluginHook({
+		cfg: transition.cfg,
+		sessionKey: transition.sessionKey,
+		sessionId: transition.previousSessionId,
+		storePath: transition.storePath,
+		sessionFile: transition.previousSessionFile,
+		agentId: transition.agentId,
+		reason: transition.previousEndReason ?? "unknown",
+		nextSessionId: transition.sessionId,
+		nextSessionKey: transition.sessionKey
+	});
+	emitGatewaySessionStartPluginHook({
+		cfg: transition.cfg,
+		sessionKey: transition.sessionKey,
+		sessionId: transition.sessionId,
+		resumedFrom: transition.previousSessionId,
+		storePath: transition.storePath,
+		sessionFile: transition.sessionFile,
+		agentId: transition.agentId
+	});
+}
+async function runSessionResetFromAgent(params) {
+	const result = await performGatewaySessionReset({
+		key: params.key,
+		...params.agentId ? { agentId: params.agentId } : {},
+		reason: params.reason,
+		commandSource: "gateway:agent"
+	});
+	if (!result.ok) return result;
+	return {
+		ok: true,
+		key: result.key,
+		sessionId: result.entry.sessionId
+	};
+}
+function resolveSessionRuntimeWorkspace(params) {
+	const sessionAgentId = params.agentId ? normalizeAgentId(params.agentId) : resolveAgentIdFromSessionKey(params.sessionKey);
+	const workspaceOverride = resolveIngressWorkspaceOverrideForSpawnedRun({
+		spawnedBy: params.spawnedBy,
+		workspaceDir: params.sessionEntry?.spawnedWorkspaceDir
+	});
+	return {
+		runtimeWorkspaceDir: workspaceOverride ?? resolveAgentWorkspaceDir(params.cfg, sessionAgentId),
+		isCanonicalWorkspace: !workspaceOverride
+	};
+}
+function resolveSessionRuntimeCwd(params) {
+	return normalizeOptionalString(params.sessionEntry?.spawnedCwd);
+}
+function shouldSkipStartupContextForSpawnedSandbox(params) {
+	if (!params.spawnedBy) return false;
+	const agentId = params.agentId ? normalizeAgentId(params.agentId) : resolveAgentIdFromSessionKey(params.sessionKey);
+	const sandboxCfg = resolveSandboxConfigForAgent(params.cfg, agentId);
+	if (sandboxCfg.mode === "off") return false;
+	if (sandboxCfg.mode === "non-main") {
+		const mainSessionKey = resolveAgentMainSessionKey({
+			cfg: params.cfg,
+			agentId
+		});
+		if (params.sessionKey.trim() === mainSessionKey.trim()) return false;
+	}
+	return sandboxCfg.workspaceAccess !== "rw";
+}
+function normalizeTrustedGroupMetadata(value) {
+	return {
+		groupId: normalizeOptionalString(value?.groupId),
+		groupChannel: normalizeOptionalString(value?.groupChannel),
+		groupSpace: normalizeOptionalString(value?.groupSpace ?? value?.space)
+	};
+}
+function resolveSessionKeyGroupId(sessionKey) {
+	const { baseSessionKey } = parseThreadSessionSuffix(sessionKey);
+	const conversation = parseRawSessionConversationRef(baseSessionKey ?? sessionKey);
+	if (!conversation || conversation.kind !== "group" && conversation.kind !== "channel") return;
+	return conversation.rawId;
+}
+function resolveTrustedGroupMetadata(params) {
+	return {
+		groupId: params.stored.groupId ?? params.inherited?.groupId ?? resolveSessionKeyGroupId(params.sessionKey) ?? (params.spawnedBy ? resolveSessionKeyGroupId(params.spawnedBy) : void 0),
+		groupChannel: params.stored.groupChannel ?? params.inherited?.groupChannel,
+		groupSpace: params.stored.groupSpace ?? params.inherited?.groupSpace
+	};
+}
+function requestGroupMatchesTrusted(params) {
+	const requestGroupId = params.requestGroupId?.trim();
+	if (!requestGroupId) return true;
+	return Boolean(params.trustedGroupId && requestGroupId === params.trustedGroupId);
+}
+function emitSessionsChanged(context, payload) {
+	const connIds = context.getSessionEventSubscriberConnIds();
+	if (connIds.size === 0) return;
+	const sessionRow = payload.sessionKey ? loadGatewaySessionRow(payload.sessionKey, payload.sessionKey === "global" && payload.agentId ? { agentId: payload.agentId } : void 0) : null;
+	const omitUnscopedGlobalGoal = payload.sessionKey === "global" && !payload.agentId;
+	context.broadcastToConnIds("sessions.changed", {
+		...payload,
+		ts: Date.now(),
+		...sessionRow ? {
+			updatedAt: sessionRow.updatedAt ?? void 0,
+			sessionId: sessionRow.sessionId,
+			kind: sessionRow.kind,
+			channel: sessionRow.channel,
+			subject: sessionRow.subject,
+			groupChannel: sessionRow.groupChannel,
+			space: sessionRow.space,
+			chatType: sessionRow.chatType,
+			origin: sessionRow.origin,
+			spawnedBy: sessionRow.spawnedBy,
+			spawnedWorkspaceDir: sessionRow.spawnedWorkspaceDir,
+			spawnedCwd: sessionRow.spawnedCwd,
+			forkedFromParent: sessionRow.forkedFromParent,
+			spawnDepth: sessionRow.spawnDepth,
+			subagentRole: sessionRow.subagentRole,
+			subagentControlScope: sessionRow.subagentControlScope,
+			label: sessionRow.label,
+			displayName: sessionRow.displayName,
+			deliveryContext: sessionRow.deliveryContext,
+			parentSessionKey: sessionRow.parentSessionKey,
+			childSessions: sessionRow.childSessions,
+			thinkingLevel: sessionRow.thinkingLevel,
+			fastMode: sessionRow.fastMode,
+			verboseLevel: sessionRow.verboseLevel,
+			traceLevel: sessionRow.traceLevel,
+			reasoningLevel: sessionRow.reasoningLevel,
+			elevatedLevel: sessionRow.elevatedLevel,
+			sendPolicy: sessionRow.sendPolicy,
+			systemSent: sessionRow.systemSent,
+			abortedLastRun: sessionRow.abortedLastRun,
+			inputTokens: sessionRow.inputTokens,
+			outputTokens: sessionRow.outputTokens,
+			lastChannel: sessionRow.lastChannel,
+			lastTo: sessionRow.lastTo,
+			lastAccountId: sessionRow.lastAccountId,
+			lastThreadId: sessionRow.lastThreadId,
+			totalTokens: sessionRow.totalTokens,
+			totalTokensFresh: sessionRow.totalTokensFresh,
+			...omitUnscopedGlobalGoal ? {} : { goal: sessionRow.goal ?? null },
+			contextTokens: sessionRow.contextTokens,
+			estimatedCostUsd: sessionRow.estimatedCostUsd,
+			responseUsage: sessionRow.responseUsage,
+			modelProvider: sessionRow.modelProvider,
+			model: sessionRow.model,
+			status: sessionRow.status,
+			startedAt: sessionRow.startedAt,
+			endedAt: sessionRow.endedAt,
+			runtimeMs: sessionRow.runtimeMs,
+			compactionCheckpointCount: sessionRow.compactionCheckpointCount,
+			latestCompactionCheckpoint: sessionRow.latestCompactionCheckpoint
+		} : {}
+	}, connIds, { dropIfSlow: true });
+}
+function resolveFailedTrackedAgentTaskStatus(error) {
+	return isAbortError(error) || isTimeoutError(error) ? "timed_out" : "failed";
+}
+function tryFinalizeTrackedAgentTask(params) {
+	try {
+		finalizeTaskRunByRunId({
+			runId: params.runId,
+			runtime: "cli",
+			status: params.status,
+			endedAt: Date.now(),
+			...params.error !== void 0 ? { error: params.error } : {},
+			...params.terminalSummary !== void 0 ? { terminalSummary: params.terminalSummary } : {}
+		});
+	} catch {}
+}
+function resolveAgentDedupeKeys(params) {
+	const keys = [`agent:${params.idempotencyKey}`];
+	const approvalId = params.execApprovalFollowupApprovalId?.trim();
+	if (approvalId) keys.push(`agent:exec-approval-followup:${approvalId}`);
+	return uniqueStrings(keys);
+}
+function readGatewayDedupeEntry(params) {
+	for (const key of params.keys) {
+		const entry = params.dedupe.get(key);
+		if (entry) return entry;
+	}
+}
+function isAcceptedAgentDedupePayload(payload) {
+	return typeof payload === "object" && payload !== null && payload.status === "accepted";
+}
+function isPreRegistrationAbortedAgentDedupePayload(payload) {
+	const stopReason = payload?.stopReason;
+	return typeof payload === "object" && payload !== null && payload.status === "timeout" && (stopReason === "rpc" || stopReason === "stop");
+}
+function isPreRegistrationAbortedAgentDedupeEntryForSession(params) {
+	if (!params.entry?.ok || !isPreRegistrationAbortedAgentDedupePayload(params.entry.payload)) return false;
+	const payload = params.entry.payload;
+	const payloadRunId = typeof payload.runId === "string" ? payload.runId.trim() : "";
+	if (payloadRunId && payloadRunId !== params.runId) return false;
+	const payloadSessionKey = typeof payload.sessionKey === "string" && payload.sessionKey.trim() ? payload.sessionKey.trim() : void 0;
+	const expectedSessionKeys = new Set([params.sessionKey, ...params.alternateSessionKeys ?? []].filter((value) => Boolean(value?.trim())));
+	return !payloadSessionKey || expectedSessionKeys.size === 0 || expectedSessionKeys.has(payloadSessionKey);
+}
+function setGatewayDedupeEntries(params) {
+	for (const key of params.keys) setGatewayDedupeEntry({
+		dedupe: params.dedupe,
+		key,
+		entry: params.entry
+	});
+}
+function setAbortedAgentDedupeEntries(params) {
+	setGatewayDedupeEntries({
+		dedupe: params.dedupe,
+		keys: params.keys,
+		entry: {
+			ts: Date.now(),
+			ok: true,
+			payload: {
+				runId: params.runId,
+				...params.agentId ? { agentId: params.agentId } : {},
+				status: "timeout",
+				summary: "aborted",
+				stopReason: params.stopReason,
+				timeoutPhase: "queue",
+				providerStarted: false
+			}
+		}
+	});
+}
+function readAgentRunTimeoutAttribution(meta) {
+	const record = meta && typeof meta === "object" && !Array.isArray(meta) ? meta : void 0;
+	return {
+		timeoutPhase: normalizeAgentRunTimeoutPhase(record?.timeoutPhase),
+		providerStarted: asBoolean(record?.providerStarted)
+	};
+}
+function isGatewayAbortSignalReason(reason) {
+	return reason === void 0 || isAbortError(reason) || readErrorName(reason) === "TimeoutError";
+}
+function isGatewayAgentAbortRejection(error, signal) {
+	if (!signal.aborted) return false;
+	if (readErrorName(signal.reason) === "TimeoutError") return true;
+	if (!isGatewayAbortSignalReason(signal.reason)) return false;
+	return isAbortError(error) || readErrorName(error) === "TimeoutError";
+}
+function resolveGatewayAgentAbortStopReason(signal) {
+	return readErrorName(signal.reason) === "TimeoutError" ? "timeout" : "rpc";
+}
+function resolveAbortedAgentStopReason(entry) {
+	return entry?.abortStopReason?.trim() || "rpc";
+}
+function deleteGatewayDedupeEntries(params) {
+	for (const key of params.keys) params.dedupe.delete(key);
+}
+function dispatchAgentRunFromGateway(params) {
+	const inputProvenance = normalizeInputProvenance(params.ingressOpts.inputProvenance);
+	const shouldTrackTask = params.ingressOpts.sessionKey?.trim() && inputProvenance?.kind !== "inter_session";
+	if (shouldTrackTask) try {
+		createRunningTaskRun({
+			runtime: "cli",
+			sourceId: params.runId,
+			ownerKey: params.ingressOpts.sessionKey,
+			scopeKind: "session",
+			requesterOrigin: normalizeDeliveryContext({
+				channel: params.ingressOpts.channel,
+				to: params.ingressOpts.to,
+				accountId: params.ingressOpts.accountId,
+				threadId: params.ingressOpts.threadId
+			}),
+			childSessionKey: params.ingressOpts.sessionKey,
+			runId: params.runId,
+			task: params.ingressOpts.message,
+			deliveryStatus: "not_applicable",
+			startedAt: Date.now()
+		});
+	} catch {}
+	agentCommandFromIngress(params.ingressOpts, defaultRuntime, params.context.deps).then((result) => {
+		const aborted = result?.meta?.aborted === true;
+		const timeoutAttribution = readAgentRunTimeoutAttribution(result?.meta);
+		if (shouldTrackTask) tryFinalizeTrackedAgentTask({
+			runId: params.runId,
+			status: aborted ? "timed_out" : "succeeded",
+			terminalSummary: aborted ? "aborted" : "completed"
+		});
+		const payload = {
+			runId: params.runId,
+			status: aborted ? "timeout" : "ok",
+			summary: aborted ? "aborted" : "completed",
+			...aborted ? { stopReason: result?.meta?.stopReason ?? "rpc" } : {},
+			...aborted && timeoutAttribution.timeoutPhase ? { timeoutPhase: timeoutAttribution.timeoutPhase } : {},
+			...aborted && timeoutAttribution.providerStarted !== void 0 ? { providerStarted: timeoutAttribution.providerStarted } : {},
+			result
+		};
+		setGatewayDedupeEntries({
+			dedupe: params.context.dedupe,
+			keys: params.dedupeKeys,
+			entry: {
+				ts: Date.now(),
+				ok: true,
+				payload
+			}
+		});
+		params.respond(true, payload, void 0, { runId: params.runId });
+	}).catch((err) => {
+		const aborted = isGatewayAgentAbortRejection(err, params.abortController.signal);
+		const renderedErr = formatForLog(err);
+		if (shouldTrackTask) tryFinalizeTrackedAgentTask({
+			runId: params.runId,
+			status: aborted ? "timed_out" : resolveFailedTrackedAgentTaskStatus(err),
+			error: renderedErr,
+			terminalSummary: renderedErr
+		});
+		const error = errorShape(ErrorCodes.UNAVAILABLE, renderedErr);
+		const stopReason = resolveGatewayAgentAbortStopReason(params.abortController.signal);
+		const payload = {
+			runId: params.runId,
+			status: aborted ? "timeout" : "error",
+			summary: aborted ? "aborted" : renderedErr,
+			...aborted ? {
+				stopReason,
+				timeoutPhase: "gateway_draining"
+			} : {}
+		};
+		setGatewayDedupeEntries({
+			dedupe: params.context.dedupe,
+			keys: params.dedupeKeys,
+			entry: {
+				ts: Date.now(),
+				ok: aborted,
+				payload,
+				...aborted ? {} : { error }
+			}
+		});
+		params.respond(aborted, payload, aborted ? void 0 : error, {
+			runId: params.runId,
+			...aborted ? {} : { error: formatForLog(err) }
+		});
+	}).finally(() => {
+		if (params.context.chatAbortControllers.get(params.runId)?.controller === params.abortController) params.context.chatAbortControllers.delete(params.runId);
+	});
+}
+function shouldSuppressAgentPromptPersistence(params) {
+	if (params.inputProvenance?.kind !== "inter_session" || params.inputProvenance.sourceTool !== "subagent_announce") return false;
+	return params.internalEvents?.some((event) => event.type === "task_completion" && event.source === "subagent") === true;
+}
+function yieldAfterAgentAcceptedAck() {
+	return new Promise((resolve) => {
+		setTimeout(resolve, 10);
+	});
+}
+const agentHandlers = {
+	agent: async ({ params, respond, context, client, isWebchatConnect }) => {
+		const p = params;
+		if (!validateAgentParams(p)) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: ${formatValidationErrors(validateAgentParams.errors)}`));
+			return;
+		}
+		const request = p;
+		const allowModelOverride = resolveAllowModelOverrideFromClient(client);
+		const canResetSession = resolveCanResetSessionFromClient(client);
+		const canUseInternalRuntimeHandoff = resolveCanUseInternalRuntimeHandoff(client);
+		const requestedModelOverride = Boolean(request.provider || request.model);
+		const requestedInternalSessionEffects = request.sessionEffects === "internal";
+		const requestedPromptPersistenceSuppression = request.suppressPromptPersistence === true;
+		const isRawModelRun = request.modelRun === true || request.promptMode === "none";
+		if (requestedModelOverride && !allowModelOverride) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "provider/model overrides are not authorized for this caller."));
+			return;
+		}
+		if ((requestedInternalSessionEffects || requestedPromptPersistenceSuppression) && !canUseInternalRuntimeHandoff) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "internal session-effect controls are reserved for backend callers."));
+			return;
+		}
+		const providerOverride = allowModelOverride ? request.provider : void 0;
+		const modelOverride = allowModelOverride ? request.model : void 0;
+		const cfg = context.getRuntimeConfig();
+		const idem = request.idempotencyKey;
+		const runId = idem;
+		const execApprovalFollowupApprovalId = parseExecApprovalFollowupApprovalId(idem);
+		if (execApprovalFollowupApprovalId && !canUseInternalRuntimeHandoff) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "exec approval followup idempotency keys are reserved for backend callers."));
+			return;
+		}
+		const normalizedSpawned = normalizeSpawnedRunMetadata({
+			groupId: request.groupId,
+			groupChannel: request.groupChannel,
+			groupSpace: request.groupSpace
+		});
+		let resolvedGroupId = normalizedSpawned.groupId;
+		let resolvedGroupChannel = normalizedSpawned.groupChannel;
+		let resolvedGroupSpace = normalizedSpawned.groupSpace;
+		let spawnedByValue;
+		const inputProvenance = normalizeInputProvenance(request.inputProvenance);
+		const preserveUserFacingSessionModelState = canUseInternalRuntimeHandoff && shouldPreserveUserFacingSessionStateForInputProvenance(inputProvenance);
+		const sessionEffects = requestedInternalSessionEffects ? "internal" : request.sessionEffects;
+		const suppressVisibleSessionEffects = sessionEffects === "internal";
+		const agentDedupeKeys = resolveAgentDedupeKeys({
+			idempotencyKey: idem,
+			execApprovalFollowupApprovalId
+		});
+		const cached = readGatewayDedupeEntry({
+			dedupe: context.dedupe,
+			keys: agentDedupeKeys
+		});
+		if (cached) {
+			if (cached.ok && isAcceptedAgentDedupePayload(cached.payload)) {
+				const cachedRunId = typeof cached.payload.runId === "string" && cached.payload.runId.trim() ? cached.payload.runId.trim() : runId;
+				const cachedSessionKey = typeof cached.payload.sessionKey === "string" && cached.payload.sessionKey.trim() ? cached.payload.sessionKey.trim() : void 0;
+				const cachedAgentId = cachedSessionKey === "global" && typeof cached.payload.agentId === "string" && cached.payload.agentId.trim() ? cached.payload.agentId.trim() : void 0;
+				respond(true, {
+					runId: cachedRunId,
+					status: "in_flight",
+					...cachedSessionKey ? { sessionKey: cachedSessionKey } : {},
+					...cachedAgentId ? { agentId: cachedAgentId } : {}
+				}, void 0, {
+					cached: true,
+					runId: cachedRunId
+				});
+				return;
+			}
+			respond(cached.ok, cached.payload, cached.error, { cached: true });
+			return;
+		}
+		let agentDedupeReserved = false;
+		let agentRunAccepted = false;
+		const ownerConnId = typeof client?.connId === "string" ? client.connId : void 0;
+		const ownerDeviceId = typeof client?.connect?.device?.id === "string" ? client.connect.device.id : void 0;
+		const reservePreAcceptedAgentDedupe = (sessionKey, dedupeAgentId) => {
+			if (agentDedupeReserved || !sessionKey) return;
+			const dedupeSessionResolvesGlobal = resolveSessionStoreKey({
+				cfg,
+				sessionKey
+			}) === "global";
+			const acceptedAt = Date.now();
+			const pendingTimeoutMs = resolveAgentTimeoutMs({
+				cfg,
+				overrideSeconds: typeof request.timeout === "number" ? request.timeout : void 0
+			});
+			setGatewayDedupeEntries({
+				dedupe: context.dedupe,
+				keys: agentDedupeKeys,
+				entry: {
+					ts: acceptedAt,
+					ok: true,
+					payload: {
+						runId,
+						status: "accepted",
+						sessionKey,
+						...dedupeSessionResolvesGlobal && dedupeAgentId ? { agentId: dedupeAgentId } : {},
+						acceptedAt,
+						dedupeKeys: agentDedupeKeys,
+						expiresAtMs: resolveAgentRunExpiresAtMs({
+							now: acceptedAt,
+							timeoutMs: pendingTimeoutMs
+						}),
+						ownerConnId,
+						ownerDeviceId
+					}
+				}
+			});
+			agentDedupeReserved = true;
+		};
+		const clearUnacceptedExecApprovalFollowupDedupe = () => {
+			if (!agentDedupeReserved || agentRunAccepted) return;
+			if (isPreRegistrationAbortedAgentDedupeEntryForSession({
+				entry: readGatewayDedupeEntry({
+					dedupe: context.dedupe,
+					keys: agentDedupeKeys
+				}),
+				runId
+			})) return;
+			deleteGatewayDedupeEntries({
+				dedupe: context.dedupe,
+				keys: agentDedupeKeys
+			});
+			agentDedupeReserved = false;
+		};
+		const normalizedAttachments = normalizeRpcAttachmentsToChatAttachments(request.attachments);
+		const requestedBestEffortDeliver = typeof request.bestEffortDeliver === "boolean" ? request.bestEffortDeliver : void 0;
+		const knownAgents = listAgentIds(cfg);
+		const agentIdRaw = normalizeOptionalString(request.agentId) ?? "";
+		let agentId = agentIdRaw ? normalizeAgentId(agentIdRaw) : void 0;
+		if (agentId && !knownAgents.includes(agentId)) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: unknown agent id "${request.agentId}"`));
+			return;
+		}
+		const requestedSessionKeyRaw = normalizeOptionalString(request.sessionKey);
+		if (requestedSessionKeyRaw && classifySessionKeyShape(requestedSessionKeyRaw) === "malformed_agent") {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: malformed session key "${requestedSessionKeyRaw}"`));
+			return;
+		}
+		if (!agentId && requestedSessionKeyRaw) {
+			const parsed = parseAgentSessionKey(requestedSessionKeyRaw);
+			const inferredAgentId = parsed && resolveSessionStoreKey({
+				cfg,
+				sessionKey: requestedSessionKeyRaw
+			}) === "global" ? normalizeAgentId(parsed.agentId) : void 0;
+			if (inferredAgentId) {
+				if (!knownAgents.includes(inferredAgentId)) {
+					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: unknown agent id "${parsed?.agentId}"`));
+					return;
+				}
+				agentId = inferredAgentId;
+			}
+		}
+		const requestedSessionId = normalizeOptionalString(request.sessionId);
+		let requestedSessionKey = requestedSessionKeyRaw ?? (!requestedSessionId ? resolveExplicitAgentSessionKey({
+			cfg,
+			agentId
+		}) : void 0);
+		if (agentId && requestedSessionKeyRaw) {
+			const parsedRequestedSessionKey = parseAgentSessionKey(requestedSessionKeyRaw);
+			const requestedCanonicalKey = resolveSessionStoreKey({
+				cfg,
+				sessionKey: requestedSessionKeyRaw
+			});
+			const sessionAgentId = parsedRequestedSessionKey?.agentId ? normalizeAgentId(parsedRequestedSessionKey.agentId) : requestedCanonicalKey === "global" ? agentId : resolveAgentIdFromSessionKey(requestedSessionKeyRaw);
+			if (sessionAgentId !== agentId) {
+				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: agent "${request.agentId}" does not match session key agent "${sessionAgentId}"`));
+				return;
+			}
+		}
+		const preAcceptedReservedSessionKey = requestedSessionKey && resolveSessionStoreKey({
+			cfg,
+			sessionKey: requestedSessionKey
+		}) === "global" ? "global" : requestedSessionKey;
+		reservePreAcceptedAgentDedupe(preAcceptedReservedSessionKey, agentId);
+		try {
+			let message = (request.message ?? "").trim();
+			if (!isRawModelRun) message = annotateInterSessionPromptText(message, inputProvenance);
+			let images = [];
+			let imageOrder = [];
+			if (normalizedAttachments.length > 0) {
+				let baseProvider;
+				let baseModel;
+				let requestedSessionEntry;
+				if (requestedSessionKeyRaw) {
+					const { cfg: sessCfg, entry: sessEntry, canonicalKey: sessCanonicalKey } = loadSessionEntry(requestedSessionKeyRaw, {
+						...agentId ? { agentId } : {},
+						clone: false
+					});
+					requestedSessionEntry = sessEntry;
+					const modelRef = resolveSessionModelRef(sessCfg, sessEntry, sessCanonicalKey === "global" && agentId ? agentId : resolveAgentIdFromSessionKey(sessCanonicalKey));
+					baseProvider = modelRef.provider;
+					baseModel = modelRef.model;
+				}
+				const effectiveProvider = providerOverride || baseProvider;
+				const effectiveModel = modelOverride || baseModel;
+				const supportsInlineImages = request.acpTurnSource === "manual_spawn" && isAcpSessionKey(requestedSessionKeyRaw) && requestedSessionEntry?.acp != null ? true : await resolveGatewayModelSupportsImages({
+					loadGatewayModelCatalog: context.loadGatewayModelCatalog,
+					provider: effectiveProvider,
+					model: effectiveModel
+				});
+				try {
+					const parsed = await parseMessageWithAttachments(message, normalizedAttachments, {
+						maxBytes: resolveChatAttachmentMaxBytes(cfg),
+						log: context.logGateway,
+						supportsInlineImages,
+						acceptNonImage: false
+					});
+					message = parsed.message.trim();
+					images = parsed.images;
+					imageOrder = parsed.imageOrder;
+				} catch (err) {
+					logAttachmentFailure(context.logGateway, "agent attachment parse failed", err);
+					respond(false, void 0, errorShape(err instanceof MediaOffloadError ? ErrorCodes.UNAVAILABLE : ErrorCodes.INVALID_REQUEST, String(err)));
+					return;
+				}
+			}
+			const isKnownGatewayChannel = (value) => isGatewayMessageChannel(value) || isInternalNonDeliveryChannel(value);
+			const channelHints = normalizeStringEntries([request.channel, request.replyChannel].filter((value) => typeof value === "string"));
+			for (const rawChannel of channelHints) {
+				const normalized = normalizeMessageChannel(rawChannel);
+				if (normalized && normalized !== "last" && !isKnownGatewayChannel(normalized)) {
+					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: unknown channel: ${normalized}`));
+					return;
+				}
+			}
+			const voiceWakeTrigger = normalizeOptionalString(request.voiceWakeTrigger) ?? "";
+			const replyTo = normalizeOptionalString(request.replyTo) ?? "";
+			const to = normalizeOptionalString(request.to) ?? "";
+			const explicitVoiceWakeSessionTarget = !agentId && requestedSessionKeyRaw ? (() => {
+				const { cfg: sessionCfg, canonicalKey } = loadSessionEntry(requestedSessionKeyRaw, { clone: false });
+				const routedAgentId = resolveAgentIdFromSessionKey(canonicalKey);
+				if (routedAgentId !== normalizeAgentId(resolveDefaultAgentId(sessionCfg))) return true;
+				return canonicalKey !== resolveAgentMainSessionKey({
+					cfg: sessionCfg,
+					agentId: routedAgentId
+				});
+			})() : false;
+			const canAutoRouteVoiceWake = !agentId && !explicitVoiceWakeSessionTarget && !requestedSessionId && !replyTo && !to;
+			if (Object.prototype.hasOwnProperty.call(request, "voiceWakeTrigger") && canAutoRouteVoiceWake) try {
+				const routingConfig = await loadVoiceWakeRoutingConfig();
+				const route = resolveVoiceWakeRouteByTrigger({
+					trigger: voiceWakeTrigger || void 0,
+					config: routingConfig
+				});
+				if ("agentId" in route) if (knownAgents.includes(route.agentId)) {
+					agentId = route.agentId;
+					requestedSessionKey = resolveExplicitAgentSessionKey({
+						cfg,
+						agentId
+					});
+				} else context.logGateway.warn(`voicewake routing ignored unknown agentId="${route.agentId}" trigger="${voiceWakeTrigger}"`);
+				else if ("sessionKey" in route) if (classifySessionKeyShape(route.sessionKey) !== "malformed_agent") {
+					const canonicalRouteSession = loadSessionEntry(route.sessionKey, { clone: false }).canonicalKey;
+					const routedAgentId = resolveAgentIdFromSessionKey(canonicalRouteSession);
+					if (knownAgents.includes(routedAgentId)) {
+						requestedSessionKey = canonicalRouteSession;
+						agentId = routedAgentId;
+					} else context.logGateway.warn(`voicewake routing ignored unknown session agent="${routedAgentId}" sessionKey="${canonicalRouteSession}" trigger="${voiceWakeTrigger}"`);
+				} else context.logGateway.warn(`voicewake routing ignored malformed sessionKey="${route.sessionKey}" trigger="${voiceWakeTrigger}"`);
+			} catch (err) {
+				context.logGateway.warn(`voicewake routing load failed: ${formatForLog(err)}`);
+			}
+			let resolvedSessionId = requestedSessionId;
+			let sessionEntry;
+			let bestEffortDeliver = requestedBestEffortDeliver ?? false;
+			let cfgForAgent;
+			let resolvedSessionKey = requestedSessionKey;
+			let resolvedSessionAgentId;
+			let isNewSession = false;
+			let skipTimestampInjection = false;
+			let shouldPrependStartupContext = false;
+			let skipAgentInitialSessionTouch = false;
+			const resetCommandMatch = message.match(RESET_COMMAND_RE);
+			if (resetCommandMatch && requestedSessionKey) {
+				if (!canResetSession) {
+					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `missing scope: ${ADMIN_SCOPE}`));
+					return;
+				}
+				const resetReason = normalizeOptionalLowercaseString(resetCommandMatch[1]) === "new" ? "new" : "reset";
+				const resetResult = await runSessionResetFromAgent({
+					key: requestedSessionKey,
+					...requestedSessionKey === "global" && agentId ? { agentId } : {},
+					reason: resetReason
+				});
+				if (!resetResult.ok) {
+					respond(false, void 0, resetResult.error);
+					return;
+				}
+				requestedSessionKey = resetResult.key;
+				resolvedSessionId = resetResult.sessionId ?? resolvedSessionId;
+				const postResetMessage = normalizeOptionalString(resetCommandMatch[2]) ?? "";
+				if (postResetMessage) message = postResetMessage;
+				else {
+					const selectedGlobalResetAgentId = requestedSessionKey === "global" && agentId ? agentId : void 0;
+					const resetLoadedSession = loadSessionEntry(requestedSessionKey, {
+						clone: false,
+						...selectedGlobalResetAgentId ? { agentId: selectedGlobalResetAgentId } : {}
+					});
+					const resetCfg = resetLoadedSession?.cfg ?? cfg;
+					const resetSessionEntry = resetLoadedSession?.entry;
+					const resetSessionAgentId = selectedGlobalResetAgentId ?? resolveAgentIdFromSessionKey(requestedSessionKey) ?? resolveDefaultAgentId(resetCfg);
+					const resetSpawnedBy = canonicalizeSpawnedByForAgent(resetCfg, resetSessionAgentId, resetSessionEntry?.spawnedBy);
+					const { runtimeWorkspaceDir, isCanonicalWorkspace } = resolveSessionRuntimeWorkspace({
+						cfg: resetCfg,
+						sessionKey: requestedSessionKey,
+						sessionEntry: resetSessionEntry,
+						spawnedBy: resetSpawnedBy,
+						agentId: resetSessionAgentId
+					});
+					const resetBaseModelRef = resolveSessionModelRef(resetCfg, resetSessionEntry, resetSessionAgentId);
+					const resetEffectiveModelRef = {
+						provider: providerOverride || resetBaseModelRef.provider,
+						model: modelOverride || resetBaseModelRef.model
+					};
+					const bareResetPromptState = await resolveBareSessionResetPromptState({
+						cfg: resetCfg,
+						workspaceDir: runtimeWorkspaceDir,
+						isPrimaryRun: !isSubagentSessionKey(requestedSessionKey) && !isAcpSessionKey(requestedSessionKey),
+						isCanonicalWorkspace,
+						hasBootstrapFileAccess: resolveBareResetBootstrapFileAccess({
+							cfg: resetCfg,
+							agentId: resetSessionAgentId,
+							sessionKey: requestedSessionKey,
+							workspaceDir: runtimeWorkspaceDir,
+							modelProvider: resetEffectiveModelRef.provider,
+							modelId: resetEffectiveModelRef.model
+						})
+					});
+					message = bareResetPromptState.prompt;
+					skipTimestampInjection = true;
+					shouldPrependStartupContext = bareResetPromptState.shouldPrependStartupContext && shouldApplyStartupContext({
+						cfg,
+						action: resetReason
+					});
+				}
+			}
+			if (!skipTimestampInjection && !isRawModelRun && inputProvenance?.kind !== "inter_session") message = injectTimestamp(message, timestampOptsFromConfig(cfg));
+			if (requestedSessionKey) {
+				const sessionLoadOptions = {
+					...agentId ? { agentId } : {},
+					clone: false
+				};
+				const { cfg, storePath, entry, canonicalKey } = loadSessionEntry(requestedSessionKey, sessionLoadOptions);
+				cfgForAgent = cfg;
+				const sessionMaintenanceConfig = resolveMaintenanceConfigFromInput(cfg.session?.maintenance);
+				const canonicalSessionAgentId = canonicalKey === "global" ? agentId ?? resolveDefaultAgentId(cfg) : resolveAgentIdFromSessionKey(canonicalKey);
+				const now = Date.now();
+				const resetPolicy = resolveSessionResetPolicy({
+					sessionCfg: cfg.session,
+					resetType: resolveSessionResetType({ sessionKey: canonicalKey }),
+					resetOverride: resolveChannelResetConfig({
+						sessionCfg: cfg.session,
+						channel: entry?.lastChannel ?? entry?.channel ?? request.channel
+					})
+				});
+				const lifecycleTimestamps = entry ? resolveSessionLifecycleTimestamps({
+					entry,
+					storePath,
+					agentId: canonicalSessionAgentId
+				}) : void 0;
+				const freshness = entry ? evaluateSessionFreshness({
+					updatedAt: entry.updatedAt,
+					...lifecycleTimestamps,
+					now,
+					policy: resetPolicy
+				}) : void 0;
+				let failedSessionTranscriptMissing = false;
+				if (entry?.status === "failed" && entry.sessionId?.trim()) try {
+					const sessionPathOpts = resolveSessionFilePathOptions({
+						storePath,
+						agentId: canonicalSessionAgentId
+					});
+					failedSessionTranscriptMissing = !existsSync(resolveSessionFilePath(entry.sessionId, entry, sessionPathOpts));
+				} catch {
+					failedSessionTranscriptMissing = true;
+				}
+				const canReuseSession = Boolean(entry?.sessionId) && (freshness?.fresh ?? false) && !failedSessionTranscriptMissing;
+				const usableRequestedSessionId = requestedSessionId && (!entry?.sessionId || canReuseSession) ? requestedSessionId : void 0;
+				const sessionId = usableRequestedSessionId ? usableRequestedSessionId : (canReuseSession ? entry?.sessionId : void 0) ?? randomUUID();
+				isNewSession = !entry || !canReuseSession && !usableRequestedSessionId || Boolean(usableRequestedSessionId && entry?.sessionId !== usableRequestedSessionId);
+				const rotatedSessionId = Boolean(entry?.sessionId && entry.sessionId !== sessionId);
+				const touchInteraction = request.bootstrapContextRunKind !== "cron" && request.bootstrapContextRunKind !== "heartbeat" && !request.internalEvents?.length;
+				const sessionAgent = canonicalSessionAgentId;
+				const requestDeliveryHint = normalizeDeliveryContext({
+					channel: request.channel?.trim(),
+					to: request.to?.trim(),
+					accountId: request.accountId?.trim(),
+					threadId: request.threadId
+				});
+				const buildSessionPatch = (freshEntry) => {
+					const freshSpawnedBy = canonicalizeSpawnedByForAgent(cfg, sessionAgent, freshEntry?.spawnedBy);
+					const storedGroup = normalizeTrustedGroupMetadata(freshEntry);
+					let inheritedGroup;
+					if (freshSpawnedBy && (!storedGroup.groupId || !storedGroup.groupChannel || !storedGroup.groupSpace)) try {
+						const parentEntry = loadSessionEntry(freshSpawnedBy)?.entry;
+						inheritedGroup = normalizeTrustedGroupMetadata({
+							groupId: parentEntry?.groupId,
+							groupChannel: parentEntry?.groupChannel,
+							groupSpace: parentEntry?.space
+						});
+					} catch {
+						inheritedGroup = void 0;
+					}
+					const trustedGroup = resolveTrustedGroupMetadata({
+						sessionKey: canonicalKey,
+						spawnedBy: freshSpawnedBy,
+						stored: storedGroup,
+						inherited: inheritedGroup
+					});
+					const nextGroup = (trustedGroup.groupId ? resolveTrustedGroupId({
+						groupId: trustedGroup.groupId,
+						sessionKey: canonicalKey,
+						spawnedBy: freshSpawnedBy
+					}) : void 0)?.dropped === true ? {
+						groupId: void 0,
+						groupChannel: void 0,
+						groupSpace: void 0
+					} : (() => {
+						const trustRequestSelectors = Boolean(trustedGroup.groupId) && requestGroupMatchesTrusted({
+							requestGroupId: normalizedSpawned.groupId,
+							trustedGroupId: trustedGroup.groupId
+						});
+						return {
+							groupId: trustedGroup.groupId,
+							groupChannel: trustedGroup.groupChannel ?? (trustRequestSelectors ? normalizedSpawned.groupChannel : void 0),
+							groupSpace: trustedGroup.groupSpace ?? (trustRequestSelectors ? normalizedSpawned.groupSpace : void 0)
+						};
+					})();
+					const deliveryFields = normalizeSessionDeliveryFields(freshEntry);
+					const effectiveDelivery = mergeDeliveryContext(deliveryFields.deliveryContext, requestDeliveryHint);
+					const effectiveDeliveryFields = normalizeSessionDeliveryFields({
+						route: deliveryFields.route,
+						deliveryContext: effectiveDelivery
+					});
+					const labelValue = normalizeOptionalString(request.label) || freshEntry?.label;
+					const channelValue = freshEntry?.channel ?? request.channel?.trim();
+					const pluginOwnerId = freshEntry === void 0 ? normalizeOptionalString(client?.internal?.pluginRuntimeOwnerId) : void 0;
+					const freshSessionRotatedSinceLoad = Boolean(entry?.sessionId && freshEntry?.sessionId && freshEntry.sessionId !== entry.sessionId);
+					const patchSessionId = freshSessionRotatedSinceLoad ? freshEntry?.sessionId : sessionId;
+					const shouldClearRotatedState = rotatedSessionId && !freshSessionRotatedSinceLoad;
+					return {
+						patch: {
+							sessionId: patchSessionId,
+							updatedAt: now,
+							...isNewSession && !freshSessionRotatedSinceLoad ? { sessionStartedAt: now } : {},
+							...touchInteraction ? { lastInteractionAt: now } : {},
+							...effectiveDeliveryFields.route ? { route: effectiveDeliveryFields.route } : {},
+							...effectiveDeliveryFields.deliveryContext ? { deliveryContext: effectiveDeliveryFields.deliveryContext } : {},
+							...effectiveDeliveryFields.lastChannel ? { lastChannel: effectiveDeliveryFields.lastChannel } : {},
+							...effectiveDeliveryFields.lastTo ? { lastTo: effectiveDeliveryFields.lastTo } : {},
+							...effectiveDeliveryFields.lastAccountId ? { lastAccountId: effectiveDeliveryFields.lastAccountId } : {},
+							...effectiveDeliveryFields.lastThreadId != null ? { lastThreadId: effectiveDeliveryFields.lastThreadId } : {},
+							...labelValue ? { label: labelValue } : {},
+							...freshSpawnedBy ? { spawnedBy: freshSpawnedBy } : {},
+							...channelValue ? { channel: channelValue } : {},
+							groupId: nextGroup.groupId,
+							groupChannel: nextGroup.groupChannel,
+							space: nextGroup.groupSpace,
+							...pluginOwnerId ? { pluginOwnerId } : {},
+							...shouldClearRotatedState ? {
+								status: void 0,
+								startedAt: void 0,
+								endedAt: void 0,
+								runtimeMs: void 0,
+								abortedLastRun: void 0,
+								sessionFile: void 0
+							} : {}
+						},
+						spawnedBy: freshSpawnedBy,
+						groupId: nextGroup.groupId,
+						groupChannel: nextGroup.groupChannel,
+						groupSpace: nextGroup.groupSpace,
+						freshSessionRotatedSinceLoad
+					};
+				};
+				let patchBuild = buildSessionPatch(entry);
+				sessionEntry = mergeSessionEntry(entry, patchBuild.patch);
+				resolvedSessionId = sessionEntry?.sessionId ?? sessionId;
+				const canonicalSessionKey = canonicalKey;
+				resolvedSessionKey = canonicalSessionKey;
+				const sessionAgentId = canonicalSessionAgentId;
+				resolvedSessionAgentId = sessionAgentId;
+				const mainSessionKey = resolveAgentMainSessionKey({
+					cfg,
+					agentId: sessionAgentId
+				});
+				const recoveredSessionStartedAt = !isNewSession && entry !== void 0 && entry.sessionStartedAt === void 0 ? resolveSessionLifecycleTimestamps({
+					entry,
+					storePath,
+					agentId: sessionAgentId
+				}).sessionStartedAt : void 0;
+				if (storePath && !suppressVisibleSessionEffects) {
+					const requestedStoreKey = requestedSessionKey;
+					let deniedBySendPolicy = false;
+					let singleEntryPersistence;
+					const persisted = await updateSessionStore(storePath, (store) => {
+						const storeKeysBeforeMigration = new Set(Object.keys(store));
+						const preMigrationTarget = resolveGatewaySessionStoreTarget({
+							cfg,
+							key: requestedStoreKey,
+							store,
+							...sessionAgentId ? { agentId: sessionAgentId } : {}
+						});
+						const hadLegacyStoreKey = preMigrationTarget.storeKeys.some((storeKey) => storeKey !== preMigrationTarget.canonicalKey && Object.prototype.hasOwnProperty.call(store, storeKey));
+						const { target, primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+							cfg,
+							key: requestedStoreKey,
+							store
+						});
+						const prunedStoreKey = [...storeKeysBeforeMigration].some((storeKey) => !Object.prototype.hasOwnProperty.call(store, storeKey));
+						const freshEntry = store[primaryKey];
+						patchBuild = buildSessionPatch(freshEntry);
+						const merged = mergeSessionEntry(freshEntry, recoveredSessionStartedAt !== void 0 && freshEntry?.sessionStartedAt === void 0 && freshEntry?.sessionId === entry?.sessionId ? {
+							...patchBuild.patch,
+							sessionStartedAt: recoveredSessionStartedAt
+						} : patchBuild.patch);
+						if ((request.deliver === true ? resolveSendPolicy({
+							cfg,
+							entry: merged,
+							sessionKey: canonicalKey,
+							channel: merged?.channel,
+							chatType: merged?.chatType
+						}) : "allow") === "deny") {
+							deniedBySendPolicy = true;
+							return merged;
+						}
+						store[primaryKey] = merged;
+						const canonicalKeyChanged = target.canonicalKey !== preMigrationTarget.canonicalKey;
+						singleEntryPersistence = freshEntry && !hadLegacyStoreKey && !canonicalKeyChanged && !prunedStoreKey ? {
+							sessionKey: primaryKey,
+							entry: merged
+						} : void 0;
+						return merged;
+					}, {
+						takeCacheOwnership: true,
+						maintenanceConfig: sessionMaintenanceConfig,
+						resolveSingleEntryPersistence: () => singleEntryPersistence
+					});
+					if (persisted) {
+						sessionEntry = persisted;
+						resolvedSessionId = sessionEntry.sessionId;
+					}
+					skipAgentInitialSessionTouch = touchInteraction;
+					if (deniedBySendPolicy) {
+						respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "send blocked by session policy"));
+						return;
+					}
+				}
+				spawnedByValue = patchBuild.spawnedBy;
+				resolvedGroupId = patchBuild.groupId;
+				resolvedGroupChannel = patchBuild.groupChannel;
+				resolvedGroupSpace = patchBuild.groupSpace;
+				if (!suppressVisibleSessionEffects && isNewSession && resolvedSessionId && storePath && !patchBuild.freshSessionRotatedSinceLoad) {
+					const previousSessionId = rotatedSessionId ? entry?.sessionId : void 0;
+					emitAgentSendSessionLifecycleTransition({
+						cfg,
+						sessionKey: canonicalSessionKey,
+						sessionId: resolvedSessionId,
+						storePath,
+						sessionFile: sessionEntry?.sessionFile,
+						agentId: sessionAgentId,
+						previousSessionId,
+						previousSessionFile: previousSessionId ? entry?.sessionFile : void 0,
+						previousEndReason: previousSessionId ? freshness?.staleReason ?? (usableRequestedSessionId && entry?.sessionId !== usableRequestedSessionId ? "new" : "unknown") : void 0
+					});
+				}
+				if (request.deliver === true) {
+					if (resolveSendPolicy({
+						cfg,
+						entry: sessionEntry,
+						sessionKey: canonicalKey,
+						channel: sessionEntry?.channel,
+						chatType: sessionEntry?.chatType
+					}) === "deny") {
+						respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "send blocked by session policy"));
+						return;
+					}
+				}
+				if (!suppressVisibleSessionEffects && (canonicalSessionKey === mainSessionKey || canonicalSessionKey === "global")) {
+					const selectedGlobalAgentId = canonicalSessionKey === "global" ? sessionAgentId : void 0;
+					context.addChatRun(idem, {
+						sessionKey: canonicalSessionKey,
+						...selectedGlobalAgentId ? { agentId: selectedGlobalAgentId } : {},
+						clientRunId: idem
+					});
+					if (requestedBestEffortDeliver === void 0) bestEffortDeliver = true;
+				}
+				registerAgentRunContext(idem, suppressVisibleSessionEffects ? { isControlUiVisible: false } : { sessionKey: canonicalSessionKey });
+			}
+			const activeSessionAgentId = resolvedSessionKey === "global" && resolvedSessionAgentId ? resolvedSessionAgentId : resolvedSessionKey ? resolveAgentIdFromSessionKey(resolvedSessionKey) : agentId ?? resolveDefaultAgentId(cfgForAgent ?? cfg);
+			const connId = typeof client?.connId === "string" ? client.connId : void 0;
+			const wantsToolEvents = hasGatewayClientCap(client?.connect?.caps, GATEWAY_CLIENT_CAPS.TOOL_EVENTS);
+			if (connId && wantsToolEvents) {
+				context.registerToolEventRecipient(runId, connId);
+				for (const [activeRunId, active] of context.chatAbortControllers) {
+					const sameSession = active.sessionKey === resolvedSessionKey;
+					const sameSelectedGlobalAgent = resolvedSessionKey === "global" ? active.agentId === activeSessionAgentId : true;
+					if (activeRunId !== runId && sameSession && sameSelectedGlobalAgent) context.registerToolEventRecipient(activeRunId, connId);
+				}
+			}
+			const wantsDelivery = request.deliver === true;
+			const explicitTo = normalizeOptionalString(request.replyTo) ?? normalizeOptionalString(request.to);
+			const explicitThreadId = normalizeOptionalString(request.threadId);
+			const turnSourceChannel = normalizeOptionalString(request.channel);
+			const turnSourceTo = normalizeOptionalString(request.to);
+			const turnSourceAccountId = normalizeOptionalString(request.accountId);
+			const deliveryPlan = await resolveAgentDeliveryPlanWithSessionRoute({
+				cfg: cfgForAgent ?? cfg,
+				agentId: activeSessionAgentId,
+				currentSessionKey: resolvedSessionKey,
+				sessionEntry,
+				requestedChannel: request.replyChannel ?? request.channel,
+				explicitTo,
+				explicitThreadId,
+				accountId: request.replyAccountId ?? request.accountId,
+				wantsDelivery,
+				turnSourceChannel,
+				turnSourceTo,
+				turnSourceAccountId,
+				turnSourceThreadId: explicitThreadId
+			});
+			let resolvedChannel = deliveryPlan.resolvedChannel;
+			let deliveryTargetMode = deliveryPlan.deliveryTargetMode;
+			let resolvedAccountId = deliveryPlan.resolvedAccountId;
+			let resolvedTo = deliveryPlan.resolvedTo;
+			let effectivePlan = deliveryPlan;
+			let deliveryDowngradeReason = null;
+			let deliveryTargetResolutionError;
+			if (wantsDelivery && resolvedChannel === "webchat") {
+				const cfgResolved = cfgForAgent ?? cfg;
+				try {
+					resolvedChannel = (await resolveMessageChannelSelection({ cfg: cfgResolved })).channel;
+					deliveryTargetMode = deliveryTargetMode ?? "implicit";
+					effectivePlan = {
+						...deliveryPlan,
+						resolvedChannel,
+						deliveryTargetMode,
+						resolvedAccountId
+					};
+				} catch (err) {
+					if (!shouldDowngradeDeliveryToSessionOnly({
+						wantsDelivery,
+						bestEffortDeliver,
+						resolvedChannel
+					})) {
+						respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, formatForLog(err)));
+						return;
+					}
+					deliveryDowngradeReason = String(err);
+				}
+			}
+			if (!resolvedTo && isDeliverableMessageChannel(resolvedChannel)) {
+				const fallback = resolveAgentOutboundTarget({
+					cfg: cfgForAgent ?? cfg,
+					plan: effectivePlan,
+					targetMode: deliveryTargetMode ?? "implicit",
+					validateExplicitTarget: false
+				});
+				if (fallback.resolvedTarget?.ok) resolvedTo = fallback.resolvedTo;
+				else if (fallback.resolvedTarget && !fallback.resolvedTarget.ok) deliveryTargetResolutionError = fallback.resolvedTarget.error;
+			}
+			if (wantsDelivery && isDeliverableMessageChannel(resolvedChannel) && !resolvedTo) {
+				if (!bestEffortDeliver) {
+					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, deliveryTargetResolutionError ? String(deliveryTargetResolutionError) : `delivery target is required for ${resolvedChannel}: pass --to/--reply-to or configure a default target`));
+					return;
+				}
+				context.logGateway.info(deliveryTargetResolutionError ? `agent delivery target missing (bestEffortDeliver): ${String(deliveryTargetResolutionError)}` : "agent delivery target missing (bestEffortDeliver): no deliverable target");
+			}
+			if (wantsDelivery && resolvedChannel === "webchat") {
+				if (!shouldDowngradeDeliveryToSessionOnly({
+					wantsDelivery,
+					bestEffortDeliver,
+					resolvedChannel
+				})) {
+					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "delivery channel is required: pass --channel/--reply-channel or use a main session with a previous channel"));
+					return;
+				}
+				context.logGateway.info(deliveryDowngradeReason ? `agent delivery downgraded to session-only (bestEffortDeliver): ${deliveryDowngradeReason}` : "agent delivery downgraded to session-only (bestEffortDeliver): no deliverable channel");
+			}
+			const normalizedTurnSource = normalizeMessageChannel(turnSourceChannel);
+			const originMessageChannel = (normalizedTurnSource && isKnownGatewayChannel(normalizedTurnSource) ? normalizedTurnSource : void 0) ?? (client?.connect && isWebchatConnect(client.connect) ? "webchat" : resolvedChannel);
+			const deliver = request.deliver === true && resolvedChannel !== "webchat";
+			const preRegistrationAbort = readGatewayDedupeEntry({
+				dedupe: context.dedupe,
+				keys: agentDedupeKeys
+			});
+			if (isPreRegistrationAbortedAgentDedupeEntryForSession({
+				entry: preRegistrationAbort,
+				runId,
+				sessionKey: resolvedSessionKey,
+				alternateSessionKeys: [preAcceptedReservedSessionKey, requestedSessionKey]
+			})) {
+				agentRunAccepted = true;
+				respond(true, preRegistrationAbort?.payload, void 0, {
+					cached: true,
+					runId
+				});
+				return;
+			}
+			const now = Date.now();
+			const timeoutMs = resolveAgentTimeoutMs({
+				cfg: cfgForAgent ?? cfg,
+				overrideSeconds: typeof request.timeout === "number" ? request.timeout : void 0
+			});
+			const activeModelProvider = providerOverride ?? resolveSessionModelRef(cfgForAgent ?? cfg, sessionEntry, activeSessionAgentId).provider;
+			const activeAuthProvider = resolveProviderIdForAuth(activeModelProvider, { config: cfgForAgent ?? cfg });
+			const activeRunAbort = registerChatAbortController({
+				chatAbortControllers: context.chatAbortControllers,
+				runId,
+				sessionId: resolvedSessionId ?? runId,
+				sessionKey: resolvedSessionKey,
+				agentId: resolvedSessionKey === "global" ? activeSessionAgentId : void 0,
+				timeoutMs,
+				now,
+				expiresAtMs: resolveAgentRunExpiresAtMs({
+					now,
+					timeoutMs
+				}),
+				ownerConnId,
+				ownerDeviceId,
+				providerId: activeModelProvider,
+				authProviderId: activeAuthProvider,
+				kind: "agent"
+			});
+			const existingRunAbort = context.chatAbortControllers.get(runId);
+			if (!activeRunAbort.registered && existingRunAbort) {
+				agentRunAccepted = existingRunAbort.kind === "agent";
+				respond(true, {
+					runId,
+					status: "in_flight"
+				}, void 0, {
+					cached: true,
+					runId
+				});
+				return;
+			}
+			const accepted = {
+				runId,
+				sessionKey: resolvedSessionKey,
+				...resolvedSessionKey === "global" ? { agentId: activeSessionAgentId } : {},
+				status: "accepted",
+				acceptedAt: Date.now()
+			};
+			const acceptedDedupePayload = {
+				...accepted,
+				dedupeKeys: agentDedupeKeys,
+				ownerConnId,
+				ownerDeviceId
+			};
+			agentRunAccepted = true;
+			setGatewayDedupeEntries({
+				dedupe: context.dedupe,
+				keys: agentDedupeKeys,
+				entry: {
+					ts: Date.now(),
+					ok: true,
+					payload: acceptedDedupePayload
+				}
+			});
+			respond(true, accepted, void 0, { runId });
+			(async () => {
+				await yieldAfterAgentAcceptedAck();
+				let dispatched = false;
+				try {
+					if (activeRunAbort.controller.signal.aborted) {
+						const stopReason = resolveAbortedAgentStopReason(activeRunAbort.entry);
+						setAbortedAgentDedupeEntries({
+							dedupe: context.dedupe,
+							keys: agentDedupeKeys,
+							agentId: resolvedSessionKey === "global" ? activeSessionAgentId : void 0,
+							runId,
+							stopReason
+						});
+						respond(true, {
+							runId,
+							status: "timeout",
+							summary: "aborted",
+							stopReason,
+							timeoutPhase: "queue",
+							providerStarted: false
+						}, void 0, { runId });
+						return;
+					}
+					if (resolvedSessionKey) await reactivateCompletedSubagentSession({
+						sessionKey: resolvedSessionKey,
+						runId
+					});
+					if (requestedSessionKey && resolvedSessionKey && isNewSession) emitSessionsChanged(context, {
+						sessionKey: resolvedSessionKey,
+						...resolvedSessionKey === "global" ? { agentId: activeSessionAgentId } : {},
+						reason: "create"
+					});
+					if (resolvedSessionKey) emitSessionsChanged(context, {
+						sessionKey: resolvedSessionKey,
+						...resolvedSessionKey === "global" ? { agentId: activeSessionAgentId } : {},
+						reason: "send"
+					});
+					if (shouldPrependStartupContext && resolvedSessionKey) {
+						const startupCfg = cfgForAgent ?? cfg;
+						if (!shouldSkipStartupContextForSpawnedSandbox({
+							cfg: startupCfg,
+							sessionKey: resolvedSessionKey,
+							spawnedBy: spawnedByValue,
+							agentId: activeSessionAgentId
+						})) {
+							const { runtimeWorkspaceDir } = resolveSessionRuntimeWorkspace({
+								cfg: startupCfg,
+								sessionKey: resolvedSessionKey,
+								sessionEntry,
+								spawnedBy: spawnedByValue,
+								agentId: activeSessionAgentId
+							});
+							const startupContextPrelude = await buildSessionStartupContextPrelude({
+								workspaceDir: runtimeWorkspaceDir,
+								cfg: startupCfg
+							});
+							if (startupContextPrelude) message = `${startupContextPrelude}\n\n${message}`;
+						}
+					}
+					if (!isRawModelRun) message = annotateInterSessionPromptText(message, inputProvenance);
+					const resolvedThreadId = explicitThreadId ?? deliveryPlan.resolvedThreadId;
+					const ingressAgentId = resolvedSessionKey === "global" ? activeSessionAgentId : agentId && (!resolvedSessionKey || resolveAgentIdFromSessionKey(resolvedSessionKey) === agentId) ? agentId : void 0;
+					let execApprovalFollowupRuntimeHandoff = canUseInternalRuntimeHandoff && execApprovalFollowupApprovalId ? consumeExecApprovalFollowupRuntimeHandoff({
+						handoffId: request.internalRuntimeHandoffId,
+						approvalId: execApprovalFollowupApprovalId,
+						idempotencyKey: idem,
+						sessionKey: resolvedSessionKey
+					}) : void 0;
+					if (!execApprovalFollowupRuntimeHandoff && canUseInternalRuntimeHandoff && execApprovalFollowupApprovalId && requestedSessionKeyRaw && requestedSessionKeyRaw !== resolvedSessionKey) execApprovalFollowupRuntimeHandoff = consumeExecApprovalFollowupRuntimeHandoff({
+						handoffId: request.internalRuntimeHandoffId,
+						approvalId: execApprovalFollowupApprovalId,
+						idempotencyKey: idem,
+						sessionKey: requestedSessionKeyRaw
+					});
+					const execApprovalFollowupElevatedDefaults = execApprovalFollowupRuntimeHandoff?.bashElevated;
+					dispatchAgentRunFromGateway({
+						ingressOpts: {
+							message,
+							images,
+							imageOrder,
+							agentId: ingressAgentId,
+							provider: providerOverride,
+							model: modelOverride,
+							to: resolvedTo,
+							sessionId: resolvedSessionId,
+							sessionKey: resolvedSessionKey,
+							thinking: request.thinking,
+							deliver,
+							deliveryTargetMode,
+							channel: resolvedChannel,
+							accountId: resolvedAccountId,
+							threadId: resolvedThreadId,
+							runContext: {
+								messageChannel: originMessageChannel,
+								accountId: resolvedAccountId,
+								groupId: resolvedGroupId,
+								groupChannel: resolvedGroupChannel,
+								groupSpace: resolvedGroupSpace,
+								currentThreadTs: resolvedThreadId != null ? String(resolvedThreadId) : void 0
+							},
+							...execApprovalFollowupElevatedDefaults ? { bashElevated: execApprovalFollowupElevatedDefaults } : {},
+							groupId: resolvedGroupId,
+							groupChannel: resolvedGroupChannel,
+							groupSpace: resolvedGroupSpace,
+							spawnedBy: spawnedByValue,
+							timeout: request.timeout?.toString(),
+							bestEffortDeliver,
+							messageChannel: originMessageChannel,
+							runId,
+							lane: request.lane,
+							modelRun: request.modelRun === true,
+							promptMode: request.promptMode,
+							extraSystemPrompt: request.extraSystemPrompt,
+							bootstrapContextMode: request.bootstrapContextMode,
+							bootstrapContextRunKind: request.bootstrapContextRunKind,
+							acpTurnSource: request.acpTurnSource,
+							internalEvents: request.internalEvents,
+							inputProvenance,
+							sessionEffects,
+							skipInitialSessionTouch: skipAgentInitialSessionTouch,
+							preserveUserFacingSessionModelState,
+							sourceReplyDeliveryMode: request.sourceReplyDeliveryMode,
+							disableMessageTool: request.disableMessageTool,
+							suppressPromptPersistence: requestedPromptPersistenceSuppression || shouldSuppressAgentPromptPersistence({
+								inputProvenance,
+								internalEvents: request.internalEvents
+							}),
+							cleanupBundleMcpOnRunEnd: request.cleanupBundleMcpOnRunEnd,
+							abortSignal: activeRunAbort.controller.signal,
+							onActiveModelSelected: ({ provider }) => {
+								updateChatRunProvider(context.chatAbortControllers, {
+									runId,
+									providerId: provider,
+									authProviderId: resolveProviderIdForAuth(provider, { config: cfgForAgent ?? cfg })
+								});
+							},
+							workspaceDir: resolveIngressWorkspaceOverrideForSpawnedRun({
+								spawnedBy: spawnedByValue,
+								workspaceDir: sessionEntry?.spawnedWorkspaceDir
+							}),
+							cwd: resolveSessionRuntimeCwd({
+								spawnedBy: spawnedByValue,
+								sessionEntry
+							}),
+							allowModelOverride
+						},
+						runId,
+						dedupeKeys: agentDedupeKeys,
+						abortController: activeRunAbort.controller,
+						respond,
+						context
+					});
+					dispatched = true;
+				} catch (err) {
+					const error = errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err));
+					const payload = {
+						runId,
+						status: "error",
+						summary: formatForLog(err)
+					};
+					setGatewayDedupeEntries({
+						dedupe: context.dedupe,
+						keys: agentDedupeKeys,
+						entry: {
+							ts: Date.now(),
+							ok: false,
+							payload,
+							error
+						}
+					});
+					respond(false, payload, error, {
+						runId,
+						error: formatForLog(err)
+					});
+				} finally {
+					if (!dispatched) activeRunAbort.cleanup();
+				}
+			})();
+		} finally {
+			clearUnacceptedExecApprovalFollowupDedupe();
+		}
+	},
+	"agent.identity.get": ({ params, respond, context }) => {
+		if (!validateAgentIdentityParams(params)) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.identity.get params: ${formatValidationErrors(validateAgentIdentityParams.errors)}`));
+			return;
+		}
+		const p = params;
+		const agentIdRaw = normalizeOptionalString(p.agentId) ?? "";
+		const sessionKeyRaw = normalizeOptionalString(p.sessionKey) ?? "";
+		let agentId = agentIdRaw ? normalizeAgentId(agentIdRaw) : void 0;
+		if (sessionKeyRaw) {
+			if (classifySessionKeyShape(sessionKeyRaw) === "malformed_agent") {
+				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.identity.get params: malformed session key "${sessionKeyRaw}"`));
+				return;
+			}
+			const resolved = resolveAgentIdFromSessionKey(sessionKeyRaw);
+			if (agentId && resolved !== agentId) {
+				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.identity.get params: agent "${agentIdRaw}" does not match session key agent "${resolved}"`));
+				return;
+			}
+			agentId = resolved;
+		}
+		const cfg = context.getRuntimeConfig();
+		const identity = resolveAssistantIdentity({
+			cfg,
+			agentId
+		});
+		const avatarValue = resolveAssistantAvatarUrl({
+			avatar: identity.avatar,
+			agentId: identity.agentId,
+			basePath: cfg.gateway?.controlUi?.basePath
+		}) ?? identity.avatar;
+		const avatarResolution = resolveAgentAvatar(cfg, identity.agentId, { includeUiOverride: true });
+		respond(true, {
+			...identity,
+			avatar: avatarValue,
+			avatarSource: resolvePublicAgentAvatarSource(avatarResolution),
+			avatarStatus: avatarResolution.kind,
+			avatarReason: avatarResolution.kind === "none" ? avatarResolution.reason : void 0
+		}, void 0);
+	},
+	"agent.wait": async ({ params, respond, context }) => {
+		if (!validateAgentWaitParams(params)) {
+			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.wait params: ${formatValidationErrors(validateAgentWaitParams.errors)}`));
+			return;
+		}
+		const p = params;
+		const runId = (p.runId ?? "").trim();
+		const timeoutMs = typeof p.timeoutMs === "number" && Number.isFinite(p.timeoutMs) ? Math.max(0, Math.floor(p.timeoutMs)) : 3e4;
+		const activeChatEntry = context.chatAbortControllers.get(runId);
+		const hasActiveChatRun = activeChatEntry !== void 0 && activeChatEntry.kind !== "agent";
+		const cachedGatewaySnapshot = readTerminalSnapshotFromGatewayDedupe({
+			dedupe: context.dedupe,
+			runId,
+			ignoreAgentTerminalSnapshot: hasActiveChatRun
+		});
+		if (cachedGatewaySnapshot) {
+			respond(true, {
+				runId,
+				status: cachedGatewaySnapshot.status,
+				startedAt: cachedGatewaySnapshot.startedAt,
+				endedAt: cachedGatewaySnapshot.endedAt,
+				error: cachedGatewaySnapshot.error,
+				stopReason: cachedGatewaySnapshot.stopReason,
+				livenessState: cachedGatewaySnapshot.livenessState,
+				yielded: cachedGatewaySnapshot.yielded,
+				pendingError: cachedGatewaySnapshot.pendingError,
+				timeoutPhase: cachedGatewaySnapshot.timeoutPhase,
+				providerStarted: cachedGatewaySnapshot.providerStarted
+			});
+			return;
+		}
+		const lifecycleAbortController = new AbortController();
+		const dedupeAbortController = new AbortController();
+		const lifecyclePromise = waitForAgentJob({
+			runId,
+			timeoutMs,
+			signal: lifecycleAbortController.signal,
+			ignoreCachedSnapshot: hasActiveChatRun
+		});
+		const dedupePromise = waitForTerminalGatewayDedupe({
+			dedupe: context.dedupe,
+			runId,
+			timeoutMs,
+			signal: dedupeAbortController.signal,
+			ignoreAgentTerminalSnapshot: hasActiveChatRun
+		});
+		const first = await Promise.race([lifecyclePromise.then((snapshot) => ({
+			source: "lifecycle",
+			snapshot
+		})), dedupePromise.then((snapshot) => ({
+			source: "dedupe",
+			snapshot
+		}))]);
+		let snapshot = first.snapshot;
+		if (snapshot) if (first.source === "lifecycle") dedupeAbortController.abort();
+		else lifecycleAbortController.abort();
+		else {
+			snapshot = first.source === "lifecycle" ? await dedupePromise : await lifecyclePromise;
+			lifecycleAbortController.abort();
+			dedupeAbortController.abort();
+		}
+		if (!snapshot) {
+			const activeRunRegistered = activeChatEntry !== void 0;
+			respond(true, {
+				runId,
+				status: "timeout",
+				timeoutPhase: activeRunRegistered ? "gateway_draining" : "queue",
+				...activeRunRegistered ? {} : { providerStarted: false }
+			});
+			return;
+		}
+		respond(true, {
+			runId,
+			status: snapshot.status,
+			startedAt: snapshot.startedAt,
+			endedAt: snapshot.endedAt,
+			error: snapshot.error,
+			stopReason: snapshot.stopReason,
+			livenessState: snapshot.livenessState,
+			yielded: snapshot.yielded,
+			pendingError: snapshot.pendingError,
+			timeoutPhase: snapshot.timeoutPhase,
+			providerStarted: snapshot.providerStarted
+		});
+	}
+};
+//#endregion
+export { agentHandlers };