DispatchFromConfigParams,

DispatchFromConfigResult,

} from "./dispatch-from-config.types.js";

import { resolveEffectiveReplyRoute } from "./effective-reply-route.js";

import { claimInboundDedupe, commitInboundDedupe, releaseInboundDedupe } from "./inbound-dedupe.js";

import { resolveReplyRoutingDecision } from "./routing-policy.js";

import { resolveRunTypingPolicy } from "./typing-policy.js";

return replyMediaPathsRuntimePromise;

}

function isSystemEventProvider(provider?: string): boolean {

return provider === "heartbeat" || provider === "cron-event" || provider === "exec-event";

}

function resolveEffectiveReplyRoute(params: {

ctx: Pick<FinalizedMsgContext, "Provider" | "OriginatingChannel" | "OriginatingTo" | "AccountId">;

entry?: Pick<SessionEntry, "deliveryContext" | "lastChannel" | "lastTo" | "lastAccountId">;

}): { channel?: string; to?: string; accountId?: string } {

if (!isSystemEventProvider(params.ctx.Provider)) {

return {

channel: params.ctx.OriginatingChannel,

to: params.ctx.OriginatingTo,

accountId: params.ctx.AccountId,

};

}

const persistedDeliveryContext = params.entry?.deliveryContext;

return {

channel:

params.ctx.OriginatingChannel ??

persistedDeliveryContext?.channel ??

params.entry?.lastChannel,

to: params.ctx.OriginatingTo ?? persistedDeliveryContext?.to ?? params.entry?.lastTo,

accountId:

params.ctx.AccountId ?? persistedDeliveryContext?.accountId ?? params.entry?.lastAccountId,

};

}

async function maybeApplyTtsToReplyPayload(

params: Parameters<Awaited<ReturnType<typeof loadTtsRuntime>>["maybeApplyTtsToPayload"]>[0],

) {

"",

) ?? "off",

});

const effectiveReplyRoute = resolveEffectiveReplyRoute({ ctx, entry: sessionStoreEntry.entry });

const replyRoute = resolveEffectiveReplyRoute({ ctx, entry: sessionStoreEntry.entry });

// Restore route thread context only from the active turn or the thread-scoped session key.

// Do not read thread ids from the normalised session store here: `origin.threadId` can be

// folded back into lastThreadId/deliveryContext during store normalisation and resurrect a

//

// Debug: `pnpm test src/auto-reply/reply/dispatch-from-config.test.ts`

const suppressAcpChildUserDelivery = isParentOwnedBackgroundAcpSession(sessionStoreEntry.entry);

const normalizedOriginatingChannel = normalizeMessageChannel(effectiveReplyRoute.channel);

const normalizedRouteReplyChannel = normalizeMessageChannel(replyRoute.channel);

const normalizedProviderChannel = normalizeMessageChannel(ctx.Provider);

const normalizedSurfaceChannel = normalizeMessageChannel(ctx.Surface);

const normalizedCurrentSurface = normalizedProviderChannel ?? normalizedSurfaceChannel;

const hasRouteReplyCandidate = Boolean(

!suppressAcpChildUserDelivery &&

!isInternalWebchatTurn &&

normalizedOriginatingChannel &&

effectiveReplyRoute.to &&

normalizedOriginatingChannel !== normalizedCurrentSurface,

normalizedRouteReplyChannel &&

replyRoute.to &&

normalizedRouteReplyChannel !== normalizedCurrentSurface,

);

const routeReplyRuntime = hasRouteReplyCandidate ? await loadRouteReplyRuntime() : undefined;

const { originatingChannel, currentSurface, shouldRouteToOriginating, shouldSuppressTyping } =

resolveReplyRoutingDecision({

provider: ctx.Provider,

surface: ctx.Surface,

explicitDeliverRoute: ctx.ExplicitDeliverRoute,

originatingChannel: effectiveReplyRoute.channel,

originatingTo: effectiveReplyRoute.to,

suppressDirectUserDelivery: suppressAcpChildUserDelivery,

isRoutableChannel: routeReplyRuntime?.isRoutableChannel ?? (() => false),

});

const originatingTo = effectiveReplyRoute.to;

const ttsChannel = shouldRouteToOriginating ? originatingChannel : currentSurface;

const {

originatingChannel: routeReplyChannel,

currentSurface,

shouldRouteToOriginating,

shouldSuppressTyping,

} = resolveReplyRoutingDecision({

provider: ctx.Provider,

surface: ctx.Surface,

explicitDeliverRoute: ctx.ExplicitDeliverRoute,

originatingChannel: replyRoute.channel,

originatingTo: replyRoute.to,

suppressDirectUserDelivery: suppressAcpChildUserDelivery,

isRoutableChannel: routeReplyRuntime?.isRoutableChannel ?? (() => false),

});

const routeReplyTo = replyRoute.to;

const deliveryChannel = shouldRouteToOriginating ? routeReplyChannel : currentSurface;

const { createReplyMediaPathNormalizer } = await loadReplyMediaPathsRuntime();

const normalizeReplyMediaPaths = createReplyMediaPathNormalizer({

cfg,

sessionKey: acpDispatchSessionKey,

workspaceDir: resolveAgentWorkspaceDir(cfg, sessionAgentId),

messageProvider: ttsChannel,

accountId: effectiveReplyRoute.accountId,

messageProvider: deliveryChannel,

accountId: replyRoute.accountId,

groupId,

groupChannel: ctx.GroupChannel,

groupSpace: ctx.GroupSpace,

payload: ReplyPayload,

options?: { abortSignal?: AbortSignal; mirror?: boolean },

) => {

if (!shouldRouteToOriginating || !originatingChannel || !originatingTo || !routeReplyRuntime) {

if (!shouldRouteToOriginating || !routeReplyChannel || !routeReplyTo || !routeReplyRuntime) {

return null;

}

return await routeReplyRuntime.routeReply({

payload,

channel: originatingChannel,

to: originatingTo,

channel: routeReplyChannel,

to: routeReplyTo,

sessionKey: ctx.SessionKey,

policySessionKey:

ctx.CommandSource === "native"

? (ctx.CommandTargetSessionKey ?? ctx.SessionKey)

: ctx.SessionKey,

accountId: effectiveReplyRoute.accountId,

accountId: replyRoute.accountId,

requesterSenderId: ctx.SenderId,

requesterSenderName: ctx.SenderName,

requesterSenderUsername: ctx.SenderUsername,

* Helper to send a payload via route-reply (async).

* Only used when actually routing to a different provider.

* Note: Only called when shouldRouteToOriginating is true, so

* originatingChannel and originatingTo are guaranteed to be defined.

* routeReplyChannel and routeReplyTo are guaranteed to be defined.

*/

const sendPayloadAsync = async (

payload: ReplyPayload,

): Promise<void> => {

// Keep the runtime guard explicit because this helper is called from nested

// reply callbacks where TypeScript cannot narrow shouldRouteToOriginating.

if (!routeReplyRuntime || !originatingChannel || !originatingTo) {

if (!routeReplyRuntime || !routeReplyChannel || !routeReplyTo) {

return;

}

if (abortSignal?.aborted) {

entry: sessionStoreEntry.entry,

sessionKey: sessionStoreEntry.sessionKey ?? sessionKey,

channel:

(shouldRouteToOriginating ? originatingChannel : undefined) ??

(shouldRouteToOriginating ? routeReplyChannel : undefined) ??

sessionStoreEntry.entry?.channel ??

effectiveReplyRoute.channel ??

replyRoute.channel ??

ctx.Surface ??

ctx.Provider ??

undefined,

const ttsPayload = await maybeApplyTtsToReplyPayload({

payload,

cfg,

channel: ttsChannel,

channel: deliveryChannel,

kind: "final",

inboundAudio,

ttsAuto: sessionTtsAuto,

images: params.replyOptions?.images,

inboundAudio,

sessionTtsAuto,

ttsChannel,

ttsChannel: deliveryChannel,

suppressUserDelivery: suppressHookUserDelivery,

shouldRouteToOriginating,

originatingChannel,

originatingTo,

originatingChannel: routeReplyChannel,

originatingTo: routeReplyTo,

shouldSendToolSummaries,

sendPolicy,

},

requestedPolicy: params.replyOptions?.typingPolicy,

suppressTyping:

suppressDelivery || params.replyOptions?.suppressTyping === true || shouldSuppressTyping,

originatingChannel,

originatingChannel: routeReplyChannel,

systemEvent: shouldRouteToOriginating,

});

const suppressDefaultToolProgressMessages =

const ttsPayload = await maybeApplyTtsToReplyPayload({

payload,

cfg,

channel: ttsChannel,

channel: deliveryChannel,

kind: "tool",

inboundAudio,

ttsAuto: sessionTtsAuto,

const ttsPayload = await maybeApplyTtsToReplyPayload({

payload,

cfg,

channel: ttsChannel,

channel: deliveryChannel,

kind: "block",

inboundAudio,

ttsAuto: sessionTtsAuto,

images: params.replyOptions?.images,

inboundAudio,

sessionTtsAuto,

ttsChannel,

ttsChannel: deliveryChannel,

suppressUserDelivery: suppressHookUserDelivery,

shouldRouteToOriginating,

originatingChannel,

originatingTo,

originatingChannel: routeReplyChannel,

originatingTo: routeReplyTo,

shouldSendToolSummaries,

sendPolicy,

isTailDispatch: true,

const ttsSyntheticReply = await maybeApplyTtsToReplyPayload({

payload: { text: accumulatedBlockText },

cfg,

channel: ttsChannel,

channel: deliveryChannel,

kind: "final",

inboundAudio,

ttsAuto: sessionTtsAuto,