@pixelzx/genesis 2026.6.4 → 2026.6.6

package/dist/dispatch-acp-DVN58m9G.js

@@ -0,0 +1,981 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { r as logVerbose } from "./globals-wYf9_gv5.js";
+import { u as resolveAgentIdFromSessionKey } from "./session-key-Cj8Hd5K-.js";
+import { i as emitAgentEvent } from "./agent-events-ZcJylLt0.js";
+import { s as hasOutboundReplyContent } from "./reply-payload-BXIttfWn.js";
+import { n as formatToolSummary, r as resolveToolDisplay } from "./tool-display-CHRuFeBq.js";
+import { t as EmbeddedBlockChunker } from "./pi-embedded-block-chunker-B5DAl_Mk.js";
+import { a as generateSecureUuid } from "./secure-random-XRbPM_Nv.js";
+import { r as prefixSystemMessage } from "./system-message-BT1T8xC_.js";
+import { t as resolveConfiguredTtsMode } from "./tts-config-DAelfCYz.js";
+import { r as resolveEffectiveBlockStreamingConfig, t as clampPositiveInteger } from "./block-streaming-CNkUg3Jh.js";
+import { t as hasInboundMedia } from "./inbound-media-CvoEfuAy.js";
+import { i as toAcpRuntimeError } from "./errors-BuUb3AyG.js";
+import { o as isSessionIdentityPending, u as resolveSessionIdentityFromMeta } from "./session-identity-CgEaiDXL.js";
+import { t as formatAcpRuntimeErrorText } from "./error-text-DZ-INkf-.js";
+import { a as resolveAcpDispatchPolicyError, i as resolveAcpAgentPolicyError } from "./policy-7eU8YJBv.js";
+import { a as resolveAcpThreadSessionDetailLines } from "./session-identifiers-6CVZxP5k.js";
+import { r as createBlockReplyPipeline } from "./block-reply-pipeline-D_OOfKQ9.js";
+import { t as resolveStatusTtsSnapshot } from "./status-config-DFNaT8jK.js";
+//#region src/auto-reply/reply/acp-stream-settings.ts
+const DEFAULT_ACP_STREAM_COALESCE_IDLE_MS = 350;
+const DEFAULT_ACP_STREAM_MAX_CHUNK_CHARS = 1800;
+const DEFAULT_ACP_REPEAT_SUPPRESSION = true;
+const DEFAULT_ACP_DELIVERY_MODE = "final_only";
+const DEFAULT_ACP_HIDDEN_BOUNDARY_SEPARATOR = "paragraph";
+const DEFAULT_ACP_HIDDEN_BOUNDARY_SEPARATOR_LIVE = "space";
+const DEFAULT_ACP_MAX_OUTPUT_CHARS = 24e3;
+const DEFAULT_ACP_MAX_SESSION_UPDATE_CHARS = 320;
+const ACP_TAG_VISIBILITY_DEFAULTS = {
+	agent_message_chunk: true,
+	tool_call: false,
+	tool_call_update: false,
+	usage_update: false,
+	available_commands_update: false,
+	current_mode_update: false,
+	config_option_update: false,
+	session_info_update: false,
+	plan: false,
+	agent_thought_chunk: false
+};
+function clampBoolean(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function resolveAcpDeliveryMode(value) {
+	if (value === "live" || value === "final_only") return value;
+	return DEFAULT_ACP_DELIVERY_MODE;
+}
+function resolveAcpHiddenBoundarySeparator(value, fallback) {
+	if (value === "none" || value === "space" || value === "newline" || value === "paragraph") return value;
+	return fallback;
+}
+function resolveAcpStreamCoalesceIdleMs(cfg) {
+	return clampPositiveInteger(cfg.acp?.stream?.coalesceIdleMs, DEFAULT_ACP_STREAM_COALESCE_IDLE_MS, {
+		min: 0,
+		max: 5e3
+	});
+}
+function resolveAcpStreamMaxChunkChars(cfg) {
+	return clampPositiveInteger(cfg.acp?.stream?.maxChunkChars, DEFAULT_ACP_STREAM_MAX_CHUNK_CHARS, {
+		min: 50,
+		max: 4e3
+	});
+}
+function resolveAcpProjectionSettings(cfg) {
+	const stream = cfg.acp?.stream;
+	const deliveryMode = resolveAcpDeliveryMode(stream?.deliveryMode);
+	const hiddenBoundaryFallback = deliveryMode === "live" ? DEFAULT_ACP_HIDDEN_BOUNDARY_SEPARATOR_LIVE : DEFAULT_ACP_HIDDEN_BOUNDARY_SEPARATOR;
+	return {
+		deliveryMode,
+		hiddenBoundarySeparator: resolveAcpHiddenBoundarySeparator(stream?.hiddenBoundarySeparator, hiddenBoundaryFallback),
+		repeatSuppression: clampBoolean(stream?.repeatSuppression, DEFAULT_ACP_REPEAT_SUPPRESSION),
+		maxOutputChars: clampPositiveInteger(stream?.maxOutputChars, DEFAULT_ACP_MAX_OUTPUT_CHARS, {
+			min: 1,
+			max: 5e5
+		}),
+		maxSessionUpdateChars: clampPositiveInteger(stream?.maxSessionUpdateChars, DEFAULT_ACP_MAX_SESSION_UPDATE_CHARS, {
+			min: 64,
+			max: 8e3
+		}),
+		tagVisibility: stream?.tagVisibility ?? {}
+	};
+}
+function resolveAcpStreamingConfig(params) {
+	const resolved = resolveEffectiveBlockStreamingConfig({
+		cfg: params.cfg,
+		provider: params.provider,
+		accountId: params.accountId,
+		maxChunkChars: resolveAcpStreamMaxChunkChars(params.cfg),
+		coalesceIdleMs: resolveAcpStreamCoalesceIdleMs(params.cfg)
+	});
+	if (params.deliveryMode === "live") return {
+		chunking: {
+			...resolved.chunking,
+			minChars: 1
+		},
+		coalescing: {
+			...resolved.coalescing,
+			minChars: 1,
+			joiner: ""
+		}
+	};
+	return resolved;
+}
+function isAcpTagVisible(settings, tag) {
+	if (!tag) return true;
+	const override = settings.tagVisibility[tag];
+	if (typeof override === "boolean") return override;
+	if (Object.prototype.hasOwnProperty.call(ACP_TAG_VISIBILITY_DEFAULTS, tag)) return ACP_TAG_VISIBILITY_DEFAULTS[tag];
+	return true;
+}
+//#endregion
+//#region src/auto-reply/reply/acp-projector.ts
+const ACP_BLOCK_REPLY_TIMEOUT_MS = 15e3;
+const ACP_LIVE_IDLE_FLUSH_FLOOR_MS = 750;
+const ACP_LIVE_IDLE_MIN_CHARS = 80;
+const ACP_LIVE_SOFT_FLUSH_CHARS = 220;
+const ACP_LIVE_HARD_FLUSH_CHARS = 480;
+const TERMINAL_TOOL_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"done",
+	"error"
+]);
+const HIDDEN_BOUNDARY_TAGS = new Set(["tool_call", "tool_call_update"]);
+function truncateText(input, maxChars) {
+	if (input.length <= maxChars) return input;
+	if (maxChars <= 1) return input.slice(0, maxChars);
+	return `${input.slice(0, maxChars - 1)}…`;
+}
+function hashText(text) {
+	return text.trim();
+}
+function normalizeToolStatus(status) {
+	return normalizeOptionalLowercaseString(status) || void 0;
+}
+function resolveHiddenBoundarySeparatorText(mode) {
+	if (mode === "space") return " ";
+	if (mode === "newline") return "\n";
+	if (mode === "paragraph") return "\n\n";
+	return "";
+}
+function shouldInsertSeparator(params) {
+	if (!params.separator) return false;
+	if (!params.nextText) return false;
+	const firstChar = params.nextText[0];
+	if (typeof firstChar === "string" && /\s/.test(firstChar)) return false;
+	const tail = params.previousTail ?? "";
+	if (!tail) return false;
+	if (params.separator === " " && /\s$/.test(tail)) return false;
+	if ((params.separator === "\n" || params.separator === "\n\n") && tail.endsWith("\n")) return false;
+	return true;
+}
+function shouldFlushLiveBufferOnBoundary(text) {
+	if (!text) return false;
+	if (text.length >= ACP_LIVE_HARD_FLUSH_CHARS) return true;
+	if (text.endsWith("\n\n")) return true;
+	if (/[.!?][)"'`]*\s$/.test(text)) return true;
+	if (text.length >= ACP_LIVE_SOFT_FLUSH_CHARS && /\s$/.test(text)) return true;
+	return false;
+}
+function shouldFlushLiveBufferOnIdle(text) {
+	if (!text) return false;
+	if (text.length >= ACP_LIVE_IDLE_MIN_CHARS) return true;
+	if (/[.!?][)"'`]*$/.test(text.trimEnd())) return true;
+	if (text.includes("\n")) return true;
+	return false;
+}
+function renderToolSummaryText(event) {
+	const detailParts = [];
+	const title = normalizeOptionalString(event.title);
+	if (title) detailParts.push(title);
+	const status = normalizeOptionalString(event.status);
+	if (status) detailParts.push(`status=${status}`);
+	const fallback = normalizeOptionalString(event.text);
+	if (detailParts.length === 0 && fallback) detailParts.push(fallback);
+	return formatToolSummary(resolveToolDisplay({
+		name: "tool_call",
+		meta: detailParts.join(" · ") || "tool call"
+	}));
+}
+function createAcpReplyProjector(params) {
+	const settings = resolveAcpProjectionSettings(params.cfg);
+	const streaming = resolveAcpStreamingConfig({
+		cfg: params.cfg,
+		provider: params.provider,
+		accountId: params.accountId,
+		deliveryMode: settings.deliveryMode
+	});
+	const createTurnBlockReplyPipeline = () => createBlockReplyPipeline({
+		onBlockReply: async (payload) => {
+			await params.deliver("block", payload);
+		},
+		timeoutMs: ACP_BLOCK_REPLY_TIMEOUT_MS,
+		coalescing: settings.deliveryMode === "live" ? void 0 : streaming.coalescing
+	});
+	let blockReplyPipeline = createTurnBlockReplyPipeline();
+	const chunker = new EmbeddedBlockChunker(streaming.chunking);
+	const liveIdleFlushMs = Math.max(streaming.coalescing.idleMs, ACP_LIVE_IDLE_FLUSH_FLOOR_MS);
+	let emittedOutputChars = 0;
+	let truncationNoticeEmitted = false;
+	let lastStatusHash;
+	let lastToolHash;
+	let lastUsageTuple;
+	let lastVisibleOutputTail;
+	let pendingHiddenBoundary = false;
+	let liveBufferText = "";
+	let liveIdleTimer;
+	const pendingToolDeliveries = [];
+	const toolLifecycleById = /* @__PURE__ */ new Map();
+	const clearLiveIdleTimer = () => {
+		if (!liveIdleTimer) return;
+		clearTimeout(liveIdleTimer);
+		liveIdleTimer = void 0;
+	};
+	const drainChunker = (force) => {
+		if (settings.deliveryMode === "final_only" && !force) return;
+		chunker.drain({
+			force,
+			emit: (chunk) => {
+				blockReplyPipeline.enqueue({ text: chunk });
+			}
+		});
+	};
+	const flushLiveBuffer = (opts) => {
+		if (settings.deliveryMode !== "live") return;
+		if (!liveBufferText) return;
+		if (opts?.idle && !shouldFlushLiveBufferOnIdle(liveBufferText)) return;
+		const text = liveBufferText;
+		liveBufferText = "";
+		chunker.append(text);
+		drainChunker(opts?.force === true);
+	};
+	const scheduleLiveIdleFlush = () => {
+		if (settings.deliveryMode !== "live") return;
+		if (liveIdleFlushMs <= 0 || !liveBufferText) return;
+		clearLiveIdleTimer();
+		liveIdleTimer = setTimeout(() => {
+			flushLiveBuffer({
+				force: true,
+				idle: true
+			});
+			if (liveBufferText) scheduleLiveIdleFlush();
+		}, liveIdleFlushMs);
+	};
+	const resetTurnState = () => {
+		clearLiveIdleTimer();
+		blockReplyPipeline.stop();
+		blockReplyPipeline = createTurnBlockReplyPipeline();
+		emittedOutputChars = 0;
+		truncationNoticeEmitted = false;
+		lastStatusHash = void 0;
+		lastToolHash = void 0;
+		lastUsageTuple = void 0;
+		lastVisibleOutputTail = void 0;
+		pendingHiddenBoundary = false;
+		liveBufferText = "";
+		pendingToolDeliveries.length = 0;
+		toolLifecycleById.clear();
+	};
+	const flushBufferedToolDeliveries = async (force) => {
+		if (!(settings.deliveryMode === "final_only" && force)) return;
+		for (const entry of pendingToolDeliveries.splice(0)) await params.deliver("tool", entry.payload, entry.meta);
+	};
+	const flush = async (force = false) => {
+		if (settings.deliveryMode === "live") {
+			clearLiveIdleTimer();
+			flushLiveBuffer({ force: true });
+		}
+		await flushBufferedToolDeliveries(force);
+		drainChunker(force);
+		await blockReplyPipeline.flush({ force });
+	};
+	const emitSystemStatus = async (text, meta, opts) => {
+		if (!params.shouldSendToolSummaries) return;
+		const bounded = truncateText(text.trim(), settings.maxSessionUpdateChars);
+		if (!bounded) return;
+		const formatted = prefixSystemMessage(bounded);
+		const hash = hashText(formatted);
+		if (settings.repeatSuppression && opts?.dedupe !== false && lastStatusHash === hash) return;
+		if (settings.deliveryMode === "final_only") pendingToolDeliveries.push({
+			payload: { text: formatted },
+			meta
+		});
+		else {
+			await flush(true);
+			await params.deliver("tool", { text: formatted }, meta);
+		}
+		lastStatusHash = hash;
+	};
+	const emitToolSummary = async (event) => {
+		if (!params.shouldSendToolSummaries) return;
+		if (!isAcpTagVisible(settings, event.tag)) return;
+		const renderedToolSummary = renderToolSummaryText(event);
+		const toolSummary = truncateText(renderedToolSummary, settings.maxSessionUpdateChars);
+		const hash = hashText(renderedToolSummary);
+		const toolCallId = normalizeOptionalString(event.toolCallId);
+		const status = normalizeToolStatus(event.status);
+		const isTerminal = status ? TERMINAL_TOOL_STATUSES.has(status) : false;
+		const isStart = status === "in_progress" || event.tag === "tool_call";
+		if (settings.repeatSuppression) {
+			if (toolCallId) {
+				const state = toolLifecycleById.get(toolCallId) ?? {
+					started: false,
+					terminal: false
+				};
+				if (isTerminal && state.terminal) return;
+				if (isStart && state.started) return;
+				if (state.lastRenderedHash === hash) return;
+				if (isStart) state.started = true;
+				if (isTerminal) state.terminal = true;
+				state.lastRenderedHash = hash;
+				toolLifecycleById.set(toolCallId, state);
+			} else if (lastToolHash === hash) return;
+		}
+		const deliveryMeta = {
+			...event.tag ? { tag: event.tag } : {},
+			...toolCallId ? { toolCallId } : {},
+			...status ? { toolStatus: status } : {},
+			allowEdit: Boolean(toolCallId && event.tag === "tool_call_update")
+		};
+		if (settings.deliveryMode === "final_only") pendingToolDeliveries.push({
+			payload: { text: toolSummary },
+			meta: deliveryMeta
+		});
+		else {
+			await flush(true);
+			await params.deliver("tool", { text: toolSummary }, deliveryMeta);
+		}
+		lastToolHash = hash;
+	};
+	const emitTruncationNotice = async () => {
+		if (truncationNoticeEmitted) return;
+		truncationNoticeEmitted = true;
+		await emitSystemStatus("output truncated", { tag: "session_info_update" }, { dedupe: false });
+	};
+	const onEvent = async (event) => {
+		if (event.type === "text_delta") {
+			if (event.stream && event.stream !== "output") return;
+			if (!isAcpTagVisible(settings, event.tag)) return;
+			let text = event.text;
+			if (!text) return;
+			if (pendingHiddenBoundary && shouldInsertSeparator({
+				separator: resolveHiddenBoundarySeparatorText(settings.hiddenBoundarySeparator),
+				previousTail: lastVisibleOutputTail,
+				nextText: text
+			})) text = `${resolveHiddenBoundarySeparatorText(settings.hiddenBoundarySeparator)}${text}`;
+			pendingHiddenBoundary = false;
+			if (emittedOutputChars >= settings.maxOutputChars) {
+				await emitTruncationNotice();
+				return;
+			}
+			const remaining = settings.maxOutputChars - emittedOutputChars;
+			const accepted = remaining < text.length ? text.slice(0, remaining) : text;
+			if (accepted.length > 0) {
+				emittedOutputChars += accepted.length;
+				lastVisibleOutputTail = accepted.slice(-1);
+				if (settings.deliveryMode === "live") {
+					liveBufferText += accepted;
+					if (shouldFlushLiveBufferOnBoundary(liveBufferText)) {
+						clearLiveIdleTimer();
+						flushLiveBuffer({ force: true });
+					} else scheduleLiveIdleFlush();
+				} else {
+					chunker.append(accepted);
+					drainChunker(false);
+				}
+			}
+			if (accepted.length < text.length) await emitTruncationNotice();
+			return;
+		}
+		if (event.type === "status") {
+			if (!isAcpTagVisible(settings, event.tag)) return;
+			if (event.tag === "usage_update" && settings.repeatSuppression) {
+				const usageTuple = typeof event.used === "number" && typeof event.size === "number" ? `${event.used}/${event.size}` : hashText(event.text);
+				if (usageTuple === lastUsageTuple) return;
+				lastUsageTuple = usageTuple;
+			}
+			await emitSystemStatus(event.text, event.tag ? { tag: event.tag } : void 0, { dedupe: true });
+			return;
+		}
+		if (event.type === "tool_call") {
+			if (!isAcpTagVisible(settings, event.tag)) {
+				if (event.tag && HIDDEN_BOUNDARY_TAGS.has(event.tag)) {
+					const status = normalizeToolStatus(event.status);
+					const isTerminal = status ? TERMINAL_TOOL_STATUSES.has(status) : false;
+					pendingHiddenBoundary = pendingHiddenBoundary || event.tag === "tool_call" || isTerminal;
+				}
+				return;
+			}
+			await emitToolSummary(event);
+			return;
+		}
+		if (event.type === "done" || event.type === "error") {
+			await flush(true);
+			resetTurnState();
+		}
+	};
+	return {
+		onEvent,
+		flush
+	};
+}
+//#endregion
+//#region src/auto-reply/reply/dispatch-acp-attachments.ts
+let dispatchAcpMediaRuntimePromise = null;
+function loadDispatchAcpMediaRuntime() {
+	dispatchAcpMediaRuntimePromise ??= import("./dispatch-acp-media.runtime-C8IVhF5K.js");
+	return dispatchAcpMediaRuntimePromise;
+}
+const ACP_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+const ACP_ATTACHMENT_TIMEOUT_MS = 1e3;
+async function resolveAcpAttachments(params) {
+	const runtime = params.runtime ?? await loadDispatchAcpMediaRuntime();
+	const mediaAttachments = runtime.normalizeAttachments(params.ctx).map((attachment) => normalizeOptionalString(attachment.path) ? Object.assign({}, attachment, { url: void 0 }) : attachment);
+	const cache = new runtime.MediaAttachmentCache(mediaAttachments, { localPathRoots: runtime.resolveMediaAttachmentLocalRoots({
+		cfg: params.cfg,
+		ctx: params.ctx
+	}) });
+	const results = [];
+	for (const attachment of mediaAttachments) {
+		const mediaType = attachment.mime ?? "application/octet-stream";
+		if (!mediaType.startsWith("image/")) continue;
+		if (!normalizeOptionalString(attachment.path)) continue;
+		try {
+			const { buffer } = await cache.getBuffer({
+				attachmentIndex: attachment.index,
+				maxBytes: ACP_ATTACHMENT_MAX_BYTES,
+				timeoutMs: ACP_ATTACHMENT_TIMEOUT_MS
+			});
+			results.push({
+				mediaType,
+				data: buffer.toString("base64")
+			});
+		} catch (error) {
+			if (runtime.isMediaUnderstandingSkipError(error)) logVerbose(`dispatch-acp: skipping attachment #${attachment.index + 1} (${error.reason})`);
+			else {
+				const errorName = error instanceof Error ? error.name : typeof error;
+				logVerbose(`dispatch-acp: failed to read attachment #${attachment.index + 1} (${errorName})`);
+			}
+		}
+	}
+	return results;
+}
+function resolveAcpInlineImageAttachments(images) {
+	if (!Array.isArray(images)) return [];
+	return images.map((image) => ({
+		mediaType: image.mimeType,
+		data: image.data
+	})).filter((image) => image.mediaType.startsWith("image/") && image.data.trim().length > 0);
+}
+//#endregion
+//#region src/auto-reply/reply/dispatch-acp-delivery.ts
+let routeReplyRuntimePromise = null;
+let dispatchAcpTtsRuntimePromise$1 = null;
+let channelPluginRuntimePromise = null;
+let messageActionRuntimePromise = null;
+function loadRouteReplyRuntime() {
+	routeReplyRuntimePromise ??= import("./route-reply.runtime-BlkEQ-s0.js");
+	return routeReplyRuntimePromise;
+}
+function loadDispatchAcpTtsRuntime$1() {
+	dispatchAcpTtsRuntimePromise$1 ??= import("./dispatch-acp-tts.runtime-D-kupYe0.js");
+	return dispatchAcpTtsRuntimePromise$1;
+}
+function loadChannelPluginRuntime() {
+	channelPluginRuntimePromise ??= import("./plugins-Crok1kUp.js");
+	return channelPluginRuntimePromise;
+}
+function loadMessageActionRuntime() {
+	messageActionRuntimePromise ??= import("./message-action-runner-Dxv-GXkn.js");
+	return messageActionRuntimePromise;
+}
+async function shouldTreatDeliveredTextAsVisible(params) {
+	if (!normalizeOptionalString(params.text)) return false;
+	if (params.kind === "final") return true;
+	const channelId = normalizeOptionalLowercaseString(params.channel);
+	if (!channelId) return false;
+	const { getChannelPlugin } = await loadChannelPluginRuntime();
+	const outbound = getChannelPlugin(channelId)?.outbound;
+	const visibilityOverride = outbound?.shouldTreatDeliveredTextAsVisible ?? outbound?.shouldTreatRoutedTextAsVisible;
+	if (visibilityOverride) return visibilityOverride({
+		kind: params.kind,
+		text: params.text
+	});
+	return false;
+}
+async function maybeApplyAcpTts(params) {
+	if (params.skipTts) return params.payload;
+	const ttsStatus = resolveStatusTtsSnapshot({
+		cfg: params.cfg,
+		sessionAuto: params.ttsAuto
+	});
+	if (!ttsStatus) return params.payload;
+	if (ttsStatus.autoMode === "inbound" && !params.inboundAudio) return params.payload;
+	if (params.kind !== "final" && resolveConfiguredTtsMode(params.cfg) === "final") return params.payload;
+	const { maybeApplyTtsToPayload } = await loadDispatchAcpTtsRuntime$1();
+	return await maybeApplyTtsToPayload({
+		payload: params.payload,
+		cfg: params.cfg,
+		channel: params.channel,
+		kind: params.kind,
+		inboundAudio: params.inboundAudio,
+		ttsAuto: params.ttsAuto
+	});
+}
+function createAcpDispatchDeliveryCoordinator(params) {
+	const state = {
+		startedReplyLifecycle: false,
+		accumulatedBlockText: "",
+		blockCount: 0,
+		deliveredFinalReply: false,
+		deliveredVisibleText: false,
+		failedVisibleTextDelivery: false,
+		queuedDirectVisibleTextDeliveries: 0,
+		settledDirectVisibleText: false,
+		routedCounts: {
+			tool: 0,
+			block: 0,
+			final: 0
+		},
+		toolMessageByCallId: /* @__PURE__ */ new Map()
+	};
+	const directChannel = normalizeOptionalLowercaseString(params.ctx.Provider ?? params.ctx.Surface);
+	const routedChannel = normalizeOptionalLowercaseString(params.originatingChannel);
+	const deliverySessionKey = normalizeOptionalString(params.sessionKey) ?? params.ctx.SessionKey;
+	const resolvedAccountId = normalizeOptionalString(params.ctx.AccountId) ?? normalizeOptionalString(params.cfg.channels?.[routedChannel ?? directChannel ?? ""]?.defaultAccount);
+	const settleDirectVisibleText = async () => {
+		if (state.settledDirectVisibleText || state.queuedDirectVisibleTextDeliveries === 0) return;
+		state.settledDirectVisibleText = true;
+		await params.dispatcher.waitForIdle();
+		const failedCounts = params.dispatcher.getFailedCounts();
+		const failedVisibleCount = failedCounts.block + failedCounts.final;
+		if (failedVisibleCount > 0) state.failedVisibleTextDelivery = true;
+		if (state.queuedDirectVisibleTextDeliveries > failedVisibleCount) state.deliveredVisibleText = true;
+	};
+	const startReplyLifecycleOnce = async () => {
+		if (state.startedReplyLifecycle) return;
+		state.startedReplyLifecycle = true;
+		if (params.suppressUserDelivery) return;
+		Promise.resolve(params.onReplyStart?.()).catch((error) => {
+			logVerbose(`dispatch-acp: reply lifecycle start failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	const tryEditToolMessage = async (payload, toolCallId) => {
+		if (!params.shouldRouteToOriginating || !params.originatingChannel || !params.originatingTo) return false;
+		const handle = state.toolMessageByCallId.get(toolCallId);
+		if (!handle?.messageId) return false;
+		const message = normalizeOptionalString(payload.text);
+		if (!message) return false;
+		try {
+			const { runMessageAction } = await loadMessageActionRuntime();
+			await runMessageAction({
+				cfg: params.cfg,
+				action: "edit",
+				params: {
+					channel: handle.channel,
+					accountId: handle.accountId,
+					to: handle.to,
+					threadId: handle.threadId,
+					messageId: handle.messageId,
+					message
+				},
+				sessionKey: params.ctx.SessionKey,
+				requesterAccountId: params.ctx.AccountId
+			});
+			state.routedCounts.tool += 1;
+			return true;
+		} catch (error) {
+			logVerbose(`dispatch-acp: tool message edit failed for ${toolCallId}: ${formatErrorMessage(error)}`);
+			return false;
+		}
+	};
+	const deliver = async (kind, payload, meta) => {
+		if (kind === "block" && normalizeOptionalString(payload.text)) {
+			if (state.accumulatedBlockText.length > 0) state.accumulatedBlockText += "\n";
+			state.accumulatedBlockText += payload.text;
+			state.blockCount += 1;
+		}
+		if (hasOutboundReplyContent(payload, { trimText: true })) await startReplyLifecycleOnce();
+		if (params.suppressUserDelivery) return false;
+		const ttsPayload = await maybeApplyAcpTts({
+			payload,
+			cfg: params.cfg,
+			channel: params.ttsChannel,
+			kind,
+			inboundAudio: params.inboundAudio,
+			ttsAuto: params.sessionTtsAuto,
+			skipTts: meta?.skipTts
+		});
+		if (params.shouldRouteToOriginating && params.originatingChannel && params.originatingTo) {
+			const toolCallId = normalizeOptionalString(meta?.toolCallId);
+			if (kind === "tool" && meta?.allowEdit === true && toolCallId) {
+				if (await tryEditToolMessage(ttsPayload, toolCallId)) return true;
+			}
+			const tracksVisibleText = await shouldTreatDeliveredTextAsVisible({
+				channel: routedChannel,
+				kind,
+				text: ttsPayload.text,
+				routed: true
+			});
+			const { routeReply } = await loadRouteReplyRuntime();
+			const result = await routeReply({
+				payload: ttsPayload,
+				channel: params.originatingChannel,
+				to: params.originatingTo,
+				sessionKey: deliverySessionKey,
+				...deliverySessionKey !== params.ctx.SessionKey ? { policySessionKey: params.ctx.SessionKey } : {},
+				accountId: resolvedAccountId,
+				requesterSenderId: params.ctx.SenderId,
+				requesterSenderName: params.ctx.SenderName,
+				requesterSenderUsername: params.ctx.SenderUsername,
+				requesterSenderE164: params.ctx.SenderE164,
+				threadId: params.ctx.MessageThreadId,
+				cfg: params.cfg
+			});
+			if (!result.ok) {
+				if (tracksVisibleText) state.failedVisibleTextDelivery = true;
+				logVerbose(`dispatch-acp: route-reply (acp/${kind}) failed: ${result.error ?? "unknown error"}`);
+				return false;
+			}
+			if (kind === "tool" && meta?.toolCallId && result.messageId) state.toolMessageByCallId.set(meta.toolCallId, {
+				channel: params.originatingChannel,
+				accountId: resolvedAccountId,
+				to: params.originatingTo,
+				...params.ctx.MessageThreadId != null ? { threadId: params.ctx.MessageThreadId } : {},
+				messageId: result.messageId
+			});
+			if (kind === "final") state.deliveredFinalReply = true;
+			if (tracksVisibleText) state.deliveredVisibleText = true;
+			state.routedCounts[kind] += 1;
+			return true;
+		}
+		const tracksVisibleText = await shouldTreatDeliveredTextAsVisible({
+			channel: directChannel,
+			kind,
+			text: ttsPayload.text,
+			routed: false
+		});
+		const delivered = kind === "tool" ? params.dispatcher.sendToolResult(ttsPayload) : kind === "block" ? params.dispatcher.sendBlockReply(ttsPayload) : params.dispatcher.sendFinalReply(ttsPayload);
+		if (kind === "final" && delivered) state.deliveredFinalReply = true;
+		if (delivered && tracksVisibleText) {
+			state.queuedDirectVisibleTextDeliveries += 1;
+			state.settledDirectVisibleText = false;
+		} else if (!delivered && tracksVisibleText) state.failedVisibleTextDelivery = true;
+		return delivered;
+	};
+	return {
+		startReplyLifecycle: startReplyLifecycleOnce,
+		deliver,
+		getBlockCount: () => state.blockCount,
+		getAccumulatedBlockText: () => state.accumulatedBlockText,
+		settleVisibleText: settleDirectVisibleText,
+		hasDeliveredFinalReply: () => state.deliveredFinalReply,
+		hasDeliveredVisibleText: () => state.deliveredVisibleText,
+		hasFailedVisibleTextDelivery: () => state.failedVisibleTextDelivery,
+		getRoutedCounts: () => ({ ...state.routedCounts }),
+		applyRoutedCounts: (counts) => {
+			counts.tool += state.routedCounts.tool;
+			counts.block += state.routedCounts.block;
+			counts.final += state.routedCounts.final;
+		}
+	};
+}
+//#endregion
+//#region src/auto-reply/reply/dispatch-acp.ts
+let dispatchAcpManagerRuntimePromise = null;
+let dispatchAcpSessionRuntimePromise = null;
+let dispatchAcpTtsRuntimePromise = null;
+function loadDispatchAcpManagerRuntime() {
+	dispatchAcpManagerRuntimePromise ??= import("./dispatch-acp-manager.runtime-C8t1i5Wt.js");
+	return dispatchAcpManagerRuntimePromise;
+}
+function loadDispatchAcpSessionRuntime() {
+	dispatchAcpSessionRuntimePromise ??= import("./dispatch-acp-session.runtime-gOIKHxCF.js");
+	return dispatchAcpSessionRuntimePromise;
+}
+function loadDispatchAcpTtsRuntime() {
+	dispatchAcpTtsRuntimePromise ??= import("./dispatch-acp-tts.runtime-D-kupYe0.js");
+	return dispatchAcpTtsRuntimePromise;
+}
+function resolveFirstContextText(ctx, keys) {
+	for (const key of keys) {
+		const value = ctx[key];
+		if (typeof value === "string") return value;
+	}
+	return "";
+}
+function resolveAcpPromptText(ctx) {
+	return resolveFirstContextText(ctx, [
+		"BodyForAgent",
+		"BodyForCommands",
+		"CommandBody",
+		"RawBody",
+		"Body"
+	]).trim();
+}
+function resolveAcpRequestId(ctx) {
+	const id = ctx.MessageSidFull ?? ctx.MessageSid ?? ctx.MessageSidFirst ?? ctx.MessageSidLast;
+	if (typeof id === "string") {
+		const normalizedId = normalizeOptionalString(id);
+		if (normalizedId) return normalizedId;
+	}
+	if (typeof id === "number" || typeof id === "bigint") return String(id);
+	return generateSecureUuid();
+}
+async function hasBoundConversationForSession(params) {
+	const channel = normalizeOptionalLowercaseString(params.channelRaw) ?? "";
+	if (!channel) return false;
+	const accountId = normalizeOptionalLowercaseString(params.accountIdRaw) ?? "";
+	const configuredDefaultAccountId = params.cfg.channels?.[channel]?.defaultAccount;
+	const normalizedAccountId = accountId || normalizeOptionalLowercaseString(configuredDefaultAccountId) || "default";
+	const { getSessionBindingService } = await loadDispatchAcpManagerRuntime();
+	return getSessionBindingService().listBySession(params.sessionKey).some((binding) => {
+		const bindingChannel = normalizeOptionalLowercaseString(binding.conversation.channel) ?? "";
+		const bindingAccountId = normalizeOptionalLowercaseString(binding.conversation.accountId) ?? "";
+		const conversationId = normalizeOptionalString(binding.conversation.conversationId) ?? "";
+		return bindingChannel === channel && (bindingAccountId || "default") === normalizedAccountId && conversationId.length > 0;
+	});
+}
+const ACP_STALE_BINDING_UNBIND_REASON = "acp-session-init-failed";
+function isStaleSessionInitError(params) {
+	if (params.code !== "ACP_SESSION_INIT_FAILED") return false;
+	return /(ACP (session )?metadata is missing|missing ACP metadata|Session is not ACP-enabled|Resource not found)/i.test(params.message);
+}
+async function maybeUnbindStaleBoundConversations(params) {
+	if (!isStaleSessionInitError(params.error)) return;
+	try {
+		const { getSessionBindingService } = await loadDispatchAcpManagerRuntime();
+		const removed = await getSessionBindingService().unbind({
+			targetSessionKey: params.targetSessionKey,
+			reason: ACP_STALE_BINDING_UNBIND_REASON
+		});
+		if (removed.length > 0) logVerbose(`dispatch-acp: removed ${removed.length} stale bound conversation(s) for ${params.targetSessionKey} after ${params.error.code}: ${params.error.message}`);
+	} catch (error) {
+		logVerbose(`dispatch-acp: failed to unbind stale bound conversations for ${params.targetSessionKey}: ${formatErrorMessage(error)}`);
+	}
+}
+async function finalizeAcpTurnOutput(params) {
+	await params.delivery.settleVisibleText();
+	let queuedFinal = params.delivery.hasDeliveredVisibleText() && !params.delivery.hasFailedVisibleTextDelivery();
+	const ttsMode = resolveConfiguredTtsMode(params.cfg);
+	const accumulatedBlockText = params.delivery.getAccumulatedBlockText();
+	const hasAccumulatedBlockText = accumulatedBlockText.trim().length > 0;
+	const ttsStatus = resolveStatusTtsSnapshot({
+		cfg: params.cfg,
+		sessionAuto: params.sessionTtsAuto
+	});
+	const canAttemptFinalTts = ttsStatus != null && !(ttsStatus.autoMode === "inbound" && !params.inboundAudio);
+	let finalMediaDelivered = false;
+	if (ttsMode === "final" && hasAccumulatedBlockText && canAttemptFinalTts) try {
+		const { maybeApplyTtsToPayload } = await loadDispatchAcpTtsRuntime();
+		const ttsSyntheticReply = await maybeApplyTtsToPayload({
+			payload: { text: accumulatedBlockText },
+			cfg: params.cfg,
+			channel: params.ttsChannel,
+			kind: "final",
+			inboundAudio: params.inboundAudio,
+			ttsAuto: params.sessionTtsAuto
+		});
+		if (ttsSyntheticReply.mediaUrl) {
+			const delivered = await params.delivery.deliver("final", {
+				mediaUrl: ttsSyntheticReply.mediaUrl,
+				audioAsVoice: ttsSyntheticReply.audioAsVoice,
+				spokenText: accumulatedBlockText
+			});
+			queuedFinal = queuedFinal || delivered;
+			finalMediaDelivered = delivered;
+		}
+	} catch (err) {
+		logVerbose(`dispatch-acp: accumulated ACP block TTS failed: ${formatErrorMessage(err)}`);
+	}
+	if (ttsMode !== "all" && hasAccumulatedBlockText && !finalMediaDelivered && !params.delivery.hasDeliveredFinalReply() && (!params.delivery.hasDeliveredVisibleText() || params.delivery.hasFailedVisibleTextDelivery())) {
+		const delivered = await params.delivery.deliver("final", { text: accumulatedBlockText }, { skipTts: true });
+		queuedFinal = queuedFinal || delivered;
+	}
+	if (params.shouldEmitResolvedIdentityNotice) {
+		const { readAcpSessionEntry } = await loadDispatchAcpSessionRuntime();
+		const currentMeta = readAcpSessionEntry({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey
+		})?.acp;
+		if (!isSessionIdentityPending(resolveSessionIdentityFromMeta(currentMeta))) {
+			const resolvedDetails = resolveAcpThreadSessionDetailLines({
+				sessionKey: params.sessionKey,
+				meta: currentMeta
+			});
+			if (resolvedDetails.length > 0) {
+				const delivered = await params.delivery.deliver("final", { text: prefixSystemMessage(["Session ids resolved.", ...resolvedDetails].join("\n")) });
+				queuedFinal = queuedFinal || delivered;
+			}
+		}
+	}
+	return queuedFinal;
+}
+async function tryDispatchAcpReply(params) {
+	const sessionKey = normalizeOptionalString(params.sessionKey);
+	if (!sessionKey || params.bypassForCommand) return null;
+	const { getAcpSessionManager } = await loadDispatchAcpManagerRuntime();
+	const acpManager = getAcpSessionManager();
+	const acpResolution = acpManager.resolveSession({
+		cfg: params.cfg,
+		sessionKey
+	});
+	if (acpResolution.kind === "none") return null;
+	const canonicalSessionKey = acpResolution.sessionKey;
+	let queuedFinal = false;
+	const delivery = createAcpDispatchDeliveryCoordinator({
+		cfg: params.cfg,
+		ctx: params.ctx,
+		dispatcher: params.dispatcher,
+		inboundAudio: params.inboundAudio,
+		sessionKey: canonicalSessionKey,
+		sessionTtsAuto: params.sessionTtsAuto,
+		ttsChannel: params.ttsChannel,
+		suppressUserDelivery: params.suppressUserDelivery,
+		shouldRouteToOriginating: params.shouldRouteToOriginating,
+		originatingChannel: params.originatingChannel,
+		originatingTo: params.originatingTo,
+		onReplyStart: params.onReplyStart
+	});
+	const identityPendingBeforeTurn = isSessionIdentityPending(resolveSessionIdentityFromMeta(acpResolution.kind === "ready" ? acpResolution.meta : void 0));
+	const shouldEmitResolvedIdentityNotice = !params.suppressUserDelivery && identityPendingBeforeTurn && (Boolean(params.ctx.MessageThreadId != null && (normalizeOptionalString(String(params.ctx.MessageThreadId)) ?? "")) || await hasBoundConversationForSession({
+		cfg: params.cfg,
+		sessionKey: canonicalSessionKey,
+		channelRaw: params.ctx.OriginatingChannel ?? params.ctx.Surface ?? params.ctx.Provider,
+		accountIdRaw: params.ctx.AccountId
+	}));
+	const resolvedAcpAgent = acpResolution.kind === "ready" ? normalizeOptionalString(acpResolution.meta.agent) ?? normalizeOptionalString(params.cfg.acp?.defaultAgent) ?? resolveAgentIdFromSessionKey(canonicalSessionKey) : resolveAgentIdFromSessionKey(canonicalSessionKey);
+	const normalizedDispatchChannel = normalizeOptionalLowercaseString(params.ctx.OriginatingChannel ?? params.ctx.Surface ?? params.ctx.Provider);
+	const explicitDispatchAccountId = normalizeOptionalString(params.ctx.AccountId);
+	const dispatchChannels = params.cfg.channels;
+	const defaultDispatchAccount = normalizedDispatchChannel == null ? void 0 : dispatchChannels?.[normalizedDispatchChannel]?.defaultAccount;
+	const effectiveDispatchAccountId = explicitDispatchAccountId ?? normalizeOptionalString(defaultDispatchAccount);
+	const projector = createAcpReplyProjector({
+		cfg: params.cfg,
+		shouldSendToolSummaries: params.shouldSendToolSummaries,
+		deliver: delivery.deliver,
+		provider: params.ctx.Surface ?? params.ctx.Provider,
+		accountId: effectiveDispatchAccountId
+	});
+	const acpDispatchStartedAt = Date.now();
+	try {
+		const dispatchPolicyError = resolveAcpDispatchPolicyError(params.cfg);
+		if (dispatchPolicyError) throw dispatchPolicyError;
+		if (acpResolution.kind === "stale") {
+			await maybeUnbindStaleBoundConversations({
+				targetSessionKey: canonicalSessionKey,
+				error: acpResolution.error
+			});
+			const delivered = await delivery.deliver("final", {
+				text: formatAcpRuntimeErrorText(acpResolution.error),
+				isError: true
+			});
+			const counts = params.dispatcher.getQueuedCounts();
+			delivery.applyRoutedCounts(counts);
+			const acpStats = acpManager.getObservabilitySnapshot(params.cfg);
+			logVerbose(`acp-dispatch: session=${sessionKey} outcome=error code=${acpResolution.error.code} latencyMs=${Date.now() - acpDispatchStartedAt} queueDepth=${acpStats.turns.queueDepth} activeRuntimes=${acpStats.runtimeCache.activeSessions}`);
+			params.recordProcessed("completed", { reason: `acp_error:${normalizeLowercaseStringOrEmpty(acpResolution.error.code)}` });
+			params.markIdle("message_completed");
+			return {
+				queuedFinal: delivered,
+				counts
+			};
+		}
+		const agentPolicyError = resolveAcpAgentPolicyError(params.cfg, resolvedAcpAgent);
+		if (agentPolicyError) throw agentPolicyError;
+		if (hasInboundMedia(params.ctx) && !params.ctx.MediaUnderstanding?.length) try {
+			const { applyMediaUnderstanding } = await loadDispatchAcpMediaRuntime();
+			await applyMediaUnderstanding({
+				ctx: params.ctx,
+				cfg: params.cfg
+			});
+		} catch (err) {
+			logVerbose(`dispatch-acp: media understanding failed, proceeding with raw content: ${formatErrorMessage(err)}`);
+		}
+		const promptText = resolveAcpPromptText(params.ctx);
+		const mediaAttachments = hasInboundMedia(params.ctx) ? await resolveAcpAttachments({
+			ctx: params.ctx,
+			cfg: params.cfg
+		}) : [];
+		const attachments = mediaAttachments.length > 0 ? mediaAttachments : resolveAcpInlineImageAttachments(params.images);
+		if (!promptText && attachments.length === 0) {
+			const counts = params.dispatcher.getQueuedCounts();
+			delivery.applyRoutedCounts(counts);
+			params.recordProcessed("completed", { reason: "acp_empty_prompt" });
+			params.markIdle("message_completed");
+			return {
+				queuedFinal: false,
+				counts
+			};
+		}
+		try {
+			await delivery.startReplyLifecycle();
+		} catch (error) {
+			logVerbose(`dispatch-acp: start reply lifecycle failed: ${formatErrorMessage(error)}`);
+		}
+		await acpManager.runTurn({
+			cfg: params.cfg,
+			sessionKey: canonicalSessionKey,
+			text: promptText,
+			attachments: attachments.length > 0 ? attachments : void 0,
+			mode: "prompt",
+			requestId: resolveAcpRequestId(params.ctx),
+			...params.abortSignal ? { signal: params.abortSignal } : {},
+			onEvent: async (event) => await projector.onEvent(event)
+		});
+		await projector.flush(true);
+		queuedFinal = await finalizeAcpTurnOutput({
+			cfg: params.cfg,
+			sessionKey: canonicalSessionKey,
+			delivery,
+			inboundAudio: params.inboundAudio,
+			sessionTtsAuto: params.sessionTtsAuto,
+			ttsChannel: params.ttsChannel,
+			shouldEmitResolvedIdentityNotice
+		}) || queuedFinal;
+		const counts = params.dispatcher.getQueuedCounts();
+		delivery.applyRoutedCounts(counts);
+		const acpStats = acpManager.getObservabilitySnapshot(params.cfg);
+		const runId = normalizeOptionalString(params.runId);
+		if (runId) emitAgentEvent({
+			runId,
+			sessionKey,
+			stream: "lifecycle",
+			data: {
+				phase: "end",
+				startedAt: acpDispatchStartedAt,
+				endedAt: Date.now()
+			}
+		});
+		logVerbose(`acp-dispatch: session=${sessionKey} outcome=ok latencyMs=${Date.now() - acpDispatchStartedAt} queueDepth=${acpStats.turns.queueDepth} activeRuntimes=${acpStats.runtimeCache.activeSessions}`);
+		params.recordProcessed("completed", { reason: "acp_dispatch" });
+		params.markIdle("message_completed");
+		return {
+			queuedFinal,
+			counts
+		};
+	} catch (err) {
+		await projector.flush(true);
+		const acpError = toAcpRuntimeError({
+			error: err,
+			fallbackCode: "ACP_TURN_FAILED",
+			fallbackMessage: "ACP turn failed before completion."
+		});
+		await maybeUnbindStaleBoundConversations({
+			targetSessionKey: canonicalSessionKey,
+			error: acpError
+		});
+		const delivered = await delivery.deliver("final", {
+			text: formatAcpRuntimeErrorText(acpError),
+			isError: true
+		});
+		queuedFinal = queuedFinal || delivered;
+		const counts = params.dispatcher.getQueuedCounts();
+		delivery.applyRoutedCounts(counts);
+		const acpStats = acpManager.getObservabilitySnapshot(params.cfg);
+		const runId = normalizeOptionalString(params.runId);
+		if (runId) emitAgentEvent({
+			runId,
+			sessionKey,
+			stream: "lifecycle",
+			data: {
+				phase: "error",
+				startedAt: acpDispatchStartedAt,
+				endedAt: Date.now(),
+				error: acpError.message
+			}
+		});
+		logVerbose(`acp-dispatch: session=${sessionKey} outcome=error code=${acpError.code} latencyMs=${Date.now() - acpDispatchStartedAt} queueDepth=${acpStats.turns.queueDepth} activeRuntimes=${acpStats.runtimeCache.activeSessions}`);
+		params.recordProcessed("completed", { reason: `acp_error:${normalizeLowercaseStringOrEmpty(acpError.code)}` });
+		params.markIdle("message_completed");
+		return {
+			queuedFinal,
+			counts
+		};
+	}
+}
+//#endregion
+export { tryDispatchAcpReply };