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

const DRAFT_MIN_INITIAL_CHARS = 30;

function appendWithOverlap(previous: string, fragment: string): string {

const maxOverlap = Math.min(previous.length, fragment.length);

for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {

if (previous.endsWith(fragment.slice(0, overlap))) {

return `${previous}${fragment.slice(overlap)}`;

}

}

return `${previous}${fragment}`;

}

function looksLikeDraftDeltaFragment(previous: string, text: string): boolean {

if (!previous || !text) {

return false;

}

if (text.startsWith(previous) || previous.startsWith(text)) {

return false;

}

if (/^\s/.test(text)) {

return true;

}

if (previous.length < DRAFT_MIN_INITIAL_CHARS) {

return true;

}

if (/\s$/.test(previous) && text.length <= DRAFT_MIN_INITIAL_CHARS) {

return true;

}

return text.length <= Math.max(16, Math.floor(previous.length / 2));

}

type DraftPartialTextUpdate = {

text: string;

delta?: string;

replace?: true;

};

function resolveDraftPartialText(previous: string, text: string): string | undefined {

if (!previous) {

return text;

}

if (text === previous) {

return undefined;

}

if (text.startsWith(previous)) {

return text;

}

if (previous.startsWith(text) && text.length < previous.length) {

function resolveDraftPartialText(

previous: string,

update: DraftPartialTextUpdate,

): string | undefined {

const nextText =

update.replace || update.delta === undefined ? update.text : `${previous}${update.delta}`;

if (nextText === previous) {

return undefined;

}

return looksLikeDraftDeltaFragment(previous, text) ? appendWithOverlap(previous, text) : text;

return nextText;

}

async function resolveStickerVisionSupport(cfg: OpenClawConfig, agentId: string) {

});

return draftLaneEventQueue;

};

type SplitLaneSegment = { lane: LaneName; text: string };

type SplitLaneSegment = { lane: LaneName; update: DraftPartialTextUpdate };

type SplitLaneSegmentsResult = {

segments: SplitLaneSegment[];

suppressedReasoningOnly: boolean;

};

const splitTextIntoLaneSegments = (

text?: string,

update: { text?: string; delta?: string; replace?: true },

isReasoning?: boolean,

): SplitLaneSegmentsResult => {

const split = splitTelegramReasoningText(text, isReasoning);

const split = splitTelegramReasoningText(update.text, isReasoning);

const splitSegments: Array<{ lane: LaneName; text: string }> = [];

const useDelta = !update.replace && update.delta !== undefined;

const segments: SplitLaneSegment[] = [];

const suppressReasoning = resolvedReasoningLevel === "off";

if (split.reasoningText && !suppressReasoning) {

segments.push({ lane: "reasoning", text: split.reasoningText });

splitSegments.push({ lane: "reasoning", text: split.reasoningText });

}

if (split.answerText) {

segments.push({ lane: "answer", text: split.answerText });

splitSegments.push({ lane: "answer", text: split.answerText });

}

for (const segment of splitSegments) {

const canApplyDelta = useDelta && splitSegments.length === 1;

segments.push({

lane: segment.lane,

update: {

text: segment.text,

...(canApplyDelta ? { delta: update.delta } : {}),

...(update.replace ? { replace: true } : {}),

},

});

}

return {

segments,

}

await rotateLaneForNewMessage(answerLane);

};

const updateDraftFromPartial = (lane: DraftLaneState, text: string | undefined) => {

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

const laneStream = lane.stream;

if (!laneStream || !text) {

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

return;

}

const previousText = lane === answerLane ? lastAnswerPartialText : lane.lastPartialText;

const nextText = resolveDraftPartialText(previousText, text);

const nextText = resolveDraftPartialText(previousText, update);

if (!nextText) {

return;

}

lane.lastPartialText = nextText;

laneStream.update(nextText);

};

const ingestDraftLaneSegments = async (text: string | undefined, isReasoning?: boolean) => {

const split = splitTextIntoLaneSegments(text, isReasoning);

const ingestDraftLaneSegments = async (

update: { text?: string; delta?: string; replace?: true },

isReasoning?: boolean,

) => {

const split = splitTextIntoLaneSegments(update, isReasoning);

for (const segment of split.segments) {

if (segment.lane === "answer") {

await prepareAnswerLaneForText();

reasoningStepState.noteReasoningHint();

reasoningStepState.noteReasoningDelivered();

}

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

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

}

};

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

| { buttons?: TelegramInlineButtons }

| undefined

)?.buttons;

const split = splitTextIntoLaneSegments(payload.text, payload.isReasoning);

const split = splitTextIntoLaneSegments(

{ text: payload.text },

payload.isReasoning,

);

const segments = split.segments;

const reply = resolveSendableOutboundReplyParts(payload);

const _hasMedia = reply.hasMedia;

) {

reasoningStepState.bufferFinalAnswer({

payload,

text: segment.text,

text: segment.update.text,

bufferedGeneration: replyFenceGeneration,

});

continue;

streamMode === "progress" &&

segment.lane === "answer" &&

info.kind === "final"

? await deliverProgressModeFinalAnswer(payload, segment.text)

? await deliverProgressModeFinalAnswer(payload, segment.update.text)

: await deliverLaneText({

laneName: segment.lane,

text: segment.text,

text: segment.update.text,

payload,

infoKind: info.kind,

buttons: telegramButtons,

answerLane.stream || reasoningLane.stream

? (payload) =>

enqueueDraftLaneEvent(async () => {

await ingestDraftLaneSegments(payload.text);

await ingestDraftLaneSegments(payload);

})

: undefined,

onReasoningStream: reasoningLane.stream

resetDraftLaneState(reasoningLane);

splitReasoningOnNextStream = false;

}

await ingestDraftLaneSegments(payload.text, true);

await ingestDraftLaneSegments(payload, true);

})

: undefined,

onAssistantMessageStart: answerLane.stream