normalizeOptionalLowercaseString,

normalizeOptionalString,

} from "../../shared/string-coerce.js";

import { createTtsDirectiveTextStreamCleaner } from "../../tts/directives.js";

import { resolveStatusTtsSnapshot } from "../../tts/status-config.js";

import { resolveConfiguredTtsMode } from "../../tts/tts-config.js";

import { resolveConfiguredTtsMode, shouldCleanTtsDirectiveText } from "../../tts/tts-config.js";

import type { FinalizedMsgContext } from "../templating.js";

import type { ReplyPayload } from "../types.js";

import type { ReplyDispatchKind, ReplyDispatcher } from "./reply-dispatcher.types.js";

type AcpDispatchDeliveryState = {

startedReplyLifecycle: boolean;

accumulatedBlockText: string;

accumulatedVisibleBlockText: string;

accumulatedBlockTtsText: string;

cleanBlockTtsDirectiveText?: ReturnType<typeof createTtsDirectiveTextStreamCleaner>;

blockCount: number;

deliveredFinalReply: boolean;

deliveredVisibleText: boolean;

) => Promise<boolean>;

getBlockCount: () => number;

getAccumulatedBlockText: () => string;

getAccumulatedVisibleBlockText: () => string;

getAccumulatedBlockTtsText: () => string;

settleVisibleText: () => Promise<void>;

hasDeliveredFinalReply: () => boolean;

hasDeliveredVisibleText: () => boolean;

const state: AcpDispatchDeliveryState = {

startedReplyLifecycle: false,

accumulatedBlockText: "",

accumulatedVisibleBlockText: "",

accumulatedBlockTtsText: "",

cleanBlockTtsDirectiveText: shouldCleanTtsDirectiveText({

cfg: params.cfg,

ttsAuto: params.sessionTtsAuto,

agentId: params.agentId,

})

? createTtsDirectiveTextStreamCleaner()

: undefined,

blockCount: 0,

deliveredFinalReply: false,

deliveredVisibleText: false,

payload: ReplyPayload,

meta?: AcpDispatchDeliveryMeta,

): Promise<boolean> => {

if (kind === "block" && normalizeOptionalString(payload.text)) {

let visiblePayload = payload;

const rawBlockText = kind === "block" ? normalizeOptionalString(payload.text) : undefined;

if (rawBlockText) {

const joinsBufferedTtsDirective =

state.cleanBlockTtsDirectiveText?.hasBufferedDirectiveText() === true;

if (state.accumulatedBlockText.length > 0) {

state.accumulatedBlockText += "\n";

}

state.accumulatedBlockText += payload.text;

state.accumulatedBlockText += rawBlockText;

if (state.accumulatedBlockTtsText.length > 0 && !joinsBufferedTtsDirective) {

state.accumulatedBlockTtsText += "\n";

}

state.accumulatedBlockTtsText += rawBlockText;

state.blockCount += 1;

if (state.cleanBlockTtsDirectiveText && !payload.isCompactionNotice) {

const text = state.cleanBlockTtsDirectiveText.push(rawBlockText);

visiblePayload = { ...payload, text: text.trim() ? text : undefined };

}

if (visiblePayload.text) {

if (state.accumulatedVisibleBlockText.length > 0) {

state.accumulatedVisibleBlockText += "\n";

}

state.accumulatedVisibleBlockText += visiblePayload.text;

}

}

if (hasOutboundReplyContent(payload, { trimText: true })) {

if (hasOutboundReplyContent(visiblePayload, { trimText: true })) {

await startReplyLifecycleOnce();

} else {

return false;

}

if (params.suppressUserDelivery) {

return false;

}

const ttsPayload = await maybeApplyAcpTts({

payload,

payload: visiblePayload,

cfg: params.cfg,

agentId: params.agentId,

channel: params.ttsChannel,

deliver,

getBlockCount: () => state.blockCount,

getAccumulatedBlockText: () => state.accumulatedBlockText,

getAccumulatedVisibleBlockText: () => state.accumulatedVisibleBlockText,

getAccumulatedBlockTtsText: () => state.accumulatedBlockTtsText,

settleVisibleText: settleDirectVisibleText,

hasDeliveredFinalReply: () => state.deliveredFinalReply,

hasDeliveredVisibleText: () => state.deliveredVisibleText,