type ChannelProgressDraftLine,

type ChannelProgressDraftCompositorLine,

createChannelProgressDraftCompositor,

resolveChannelProgressDraftLabel,

resolveChannelStreamingBlockEnabled,

resolveTranscriptBackedChannelFinalText,

} from "openclaw/plugin-sdk/channel-outbound";

/** Minimum chars before sending first streaming message (improves push notification UX) */

const DRAFT_MIN_INITIAL_CHARS = 30;

const DRAFT_MIN_INITIAL_DELAY_MS = 5_000;

type DraftPartialTextUpdate = {

text: string;

return text.replaceAll("`", "'");

}

function formatProgressAsMarkdownCode(text: string): string {

const clipped = clipProgressMarkdownText(text);

return `\`${sanitizeProgressMarkdownText(clipped)}\``;

}

function formatTelegramProgressLine(text: string): string {

const trimmed = text.trim();

return trimmed.startsWith("_") && trimmed.endsWith("_")

? trimmed

: formatProgressAsMarkdownCode(text);

}

function escapeTelegramProgressHtml(text: string): string {

return text

.replaceAll("&", "&")

.replaceAll('"', """);

}

function renderTelegramProgressStringLine(text: string): string {

const clipped = clipProgressMarkdownText(text.trim());

function normalizeTelegramProgressText(text: string, options?: { trim?: boolean }): string {

const source = options?.trim === false ? text : text.trim();

const clipped = clipProgressMarkdownText(source);

const italic = clipped.match(/^_(.*)_$/u);

if (italic) {

return `<i>${escapeTelegramProgressHtml(italic[1] ?? "")}</i>`;

return italic[1] ?? "";

}

return clipped;

}

function formatTelegramProgressLine(text: string): string {

return sanitizeProgressMarkdownText(normalizeTelegramProgressText(text, { trim: false }));

}

function renderTelegramProgressHtmlStringLine(text: string): string {

const normalized = normalizeTelegramProgressText(text);

const italic = text.trim().match(/^_(.*)_$/u);

if (italic) {

return `<i>${escapeTelegramProgressHtml(normalized)}</i>`;

}

return `<code>${escapeTelegramProgressHtml(clipped)}</code>`;

return `<code>${escapeTelegramProgressHtml(normalized)}</code>`;

}

function renderTelegramProgressLine(line: ChannelProgressDraftCompositorLine): string {

function renderTelegramProgressHtmlLine(line: ChannelProgressDraftCompositorLine): string {

if (typeof line === "string") {

return line.split(/\r?\n/u).map(renderTelegramProgressStringLine).filter(Boolean).join("<br>");

return line

.split(/\r?\n/u)

.map(renderTelegramProgressHtmlStringLine)

.filter(Boolean)

.join("\n");

}

if (!line.icon && line.label === "Commentary") {

return renderTelegramProgressStringLine(line.text);

return renderTelegramProgressHtmlStringLine(line.text);

}

const label = [line.icon, line.label].filter(Boolean).join(" ");

const parts = [`<b>${escapeTelegramProgressHtml(label)}</b>`];

} else {

const text = line.text.trim();

if (text && text !== label) {

parts.push(renderTelegramProgressStringLine(text));

parts.push(renderTelegramProgressHtmlStringLine(text));

}

}

if (line.status && line.status !== "completed" && line.status !== line.detail) {

function renderTelegramProgressDraftPreview(

text: string,

lines: readonly ChannelProgressDraftCompositorLine[],

richMessages: boolean,

label: string | undefined,

): TelegramDraftPreview {

const trimmed = text.trimEnd();

const [heading] = trimmed.split(/\r?\n/u, 1);

const renderedLines = lines.map(renderTelegramProgressLine).filter(Boolean);

const htmlParts = heading?.trim()

? [`<b>${escapeTelegramProgressHtml(heading.trim())}</b>`, ...renderedLines]

: renderedLines;

const html = htmlParts.join("<br>");

if (!richMessages) {

return { text: html, parseMode: "HTML" };

}

const textLines = trimmed.split(/\r?\n/u);

const labelVisible =

label !== undefined && (trimmed === label || (textLines[0] === label && textLines[1] === ""));

const bodyLines = labelVisible ? textLines.slice(textLines[1] === "" ? 2 : 1) : textLines;

const renderedLines = lines.map(renderTelegramProgressHtmlLine).filter(Boolean);

const visibleLines = renderedLines.slice(-bodyLines.filter(Boolean).length);

const htmlParts = labelVisible

? [`<b>${escapeTelegramProgressHtml(label)}</b>`, ...visibleLines]

: visibleLines;

const html = htmlParts.join("\n");

return {

text: trimmed,

richMessage: buildTelegramRichHtml(html, { skipEntityDetection: true }),

replyToMessageId: draftReplyToMessageId,

richMessages: telegramCfg.richMessages,

minInitialChars: draftMinInitialChars,

minInitialDelayMs: draftMinInitialChars > 0 ? DRAFT_MIN_INITIAL_DELAY_MS : undefined,

renderText: renderStreamText,

onSupersededPreview: (superseded) => {

if (superseded.retain) {

renderTelegramProgressDraftPreview(

streamText,

options?.lines ?? [],

telegramCfg.richMessages === true,

resolveChannelProgressDraftLabel({ entry: telegramCfg, seed: progressSeed }),

),

);

if (options?.flush) {

recomputeQueuedAnswerBlockRotations();

}

};

const updateDraftFromPartial = async (lane: DraftLaneState, update: DraftPartialTextUpdate) => {

const updateDraftFromPartial = (lane: DraftLaneState, update: DraftPartialTextUpdate) => {

const laneStream = lane.stream;

if (!laneStream || !update.text) {

return;

}

if (lane === answerLane) {

if (streamMode === "progress") {

await progressDraft.noteActivity();

return;

}

resetAnswerToolProgressDraft();

reasoningStepState.noteReasoningHint();

reasoningStepState.noteReasoningDelivered();

}

await updateDraftFromPartial(lanes[segment.lane], segment.update);

updateDraftFromPartial(lanes[segment.lane], segment.update);

}

};

const flushDraftLane = async (lane: DraftLaneState) => {

}

if (segment.lane === "answer" && info.kind === "tool") {

if (verboseProgressActive()) {

if (streamMode === "progress") {

await rotateAnswerLaneAfterToolProgress();

}

if (

await sendPayload(

applyTextToPayload(effectivePayload, segment.update.text),

}

return;

}

if (streamMode === "progress" && info.kind === "tool") {

await rotateAnswerLaneAfterToolProgress();

}

const delivered = await sendPayload(effectivePayload, {

durable: info.kind === "final",

});