Fix streaming text sanitization to prevent non-monotonic output

Fixes #8537

Summary

This PR fixes a streaming text bug where the sanitizeUserFacingText function's duplicate-block collapsing behavior caused non-monotonic output during streaming, resulting in lost textin the draft stream. The fix introduces a streaming mode that bypasses the duplicate-blockcollapsing logic while preserving other sanitization behaviors.

Files Changed

Code Changes

errors.ts - New Streaming Mode

export function sanitizeUserFacingText(text: string, opts?: { streaming?: boolean }): string{
  // ... existing logic ...

  // Skip duplicate-block collapsing during streaming: the function is stateless
  // and can produce non-monotonic output as chunk boundaries shift, which causes
  // the downstream draft stream to lose accumulated text.
  if (opts?.streaming) {
    return stripped;
  }

  return collapseConsecutiveDuplicateBlocks(stripped);
}

pi-embedded-subscribe.handlers.messages.ts - Partial Overlap Handling

} else {
  // Partial overlap: deltaBuffer includes content as a substring but
  // neither is a prefix of the other. Use the suffix of content that
  // extends beyond the current deltaBuffer to avoid dropping text.
  const overlapIdx = content.indexOf(ctx.state.deltaBuffer);
  if (overlapIdx >= 0) {
    chunk = content.slice(0, overlapIdx);
  }
}

bot-message-dispatch.ts - Recovery Fix

} else {
  // Non-monotonic stream (e.g. sanitizer changed output shape).
  // Recover by using the full `text` as the new baseline instead of
  // losing all previously accumulated content.
  draftChunker?.reset();
  draftText = "";
  delta = text;  // <-- Previously missing, caused text loss
}

Reason for Changes

The collapseConsecutiveDuplicateBlocks function is stateless and operates on whatever textit receives at any given moment. During streaming, chunk boundaries shift as more content arrives, which can cause the function to produce different output shapes for the same logical content at different times. This non-monotonic behavior caused downstream consumers to detect a "reset" condition and discard accumulated text.

Impact of Changes

1. Streaming reliability: Text will no longer be lost during streaming due to sanitizer output shape changes
2. Final output unchanged: The final delivered message still uses extractAssistantText, so duplicate collapsing still applies to completed messages
3. Telegram bot stability: Non-monotonic streams now recover gracefully instead of losing all prior content

Test Plan

New unit tests verify:

• Streaming mode preserves text that would otherwise be collapsed
• Streaming mode still strips <final> tags
• Streaming mode still sanitizes error messages

it("skips duplicate-block collapsing in streaming mode", () => {
  const text = "Hello there!\n\nHello there!";
  expect(sanitizeUserFacingText(text)).toBe("Hello there!");
  expect(sanitizeUserFacingText(text, { streaming: true })).toBe(text);
});

Additional Notes

• The partial overlap logic in handleMessageUpdate handles an edge case where neither the new content nor the buffer is a prefix of the other, but they share a substring relationship
• The comment notes that leaving chunk as empty string is safe because final delivery doesn't rely on deltaBuffer

Greptile Overview

Greptile Summary

This PR introduces a streaming option to sanitizeUserFacingText so that streaming paths can bypass stateless duplicate-paragraph collapsing (which can change output shape across chunk boundaries), while preserving other sanitization behaviors like stripping <final> tags and rewriting common API/role-ordering errors. It also adjusts streaming/draft consumers (agent runner, Telegram draft streaming) to handle non-monotonic streams more safely by recovering with a full-text baseline instead of discarding accumulated text, and adds unit tests for the new streaming mode.

These changes fit into the codebase’s partial-reply pipelines by making sanitization predictable for incremental updates, while keeping the existing “final” message behavior (including duplicate collapsing) unchanged for completed deliveries.

Confidence Score: 5/5

• This PR is safe to merge.
• Most changes are localized and add test coverage for the new sanitization mode, and the Telegram recovery change is straightforward.

_{(2/5) Greptile learns from your feedback when you react with thumbs up/down!}