Summary

• Problem: In partial draft streaming, Telegram finalization would attempt editMessageText with unchanged content.
• Why it matters: Telegram reject same-content edits (message is not modified), which trigger failover cleanup/send and create duplicate visible messages plus producing error logs.
• What changed: Added lastAppliedText() tracking in src/telegram/draft-stream.ts and used it in src/telegram/bot-message-dispatch.ts to short-circuit unchanged final edits when no mutation is needed.
• What changed: Kept final edit behavior for real mutations (formatting pass, inline buttons, linkPreview=false) and expanded tests in src/telegram/draft-stream.test.ts and src/telegram/bot-message-dispatch.test.ts.

Change Type

• Bug fix

Scope (select all touched areas)

• Integrations

Related Fix

Note: Commit ac2ede5 by @steipete already treats message is not modified API errors as success, which prevents the failover/duplicate behavior. This PR adds a complementary optimization that prevents the unnecessary API call from being attempted in the first place by tracking lastAppliedText() and short-circuiting when no edit is needed.

Both fixes work together:

• ac2ede5bb: Reactive safety net at the API error handling layer
• This PR: Proactive optimization at the logic layer to avoid the no-op API call entirely
  Both fixes work together:
• ac2ede5bb: Reactive safety net at the API error handling layer
• This PR: Proactive optimization at the logic layer to avoid the no-op API call entirely

User-visible / Behavior Changes

• Telegram streamed replies no longer attempt redundant same-content final edits.
• Reduces duplicate resend behavior after finalization failover in partial streaming mode.
• no error fatigue on logs

Security Impact (required)

• New permissions/capabilities? (No)
• Secrets/tokens handling changed? (No)
• New/changed network calls? (No)
• Command/tool execution surface changed? (No)
• Data access scope changed? (No)

Repro + Verification

Environment

• OS: macOS
• Runtime/container: Node + pnpm (repo default)
• Model/provider: gpt-5.3-codex
• Integration/channel (if any): Telegram
• Relevant config (redacted): channels.telegram.streamMode=partial,
  channels.telegram.blockStreaming=false

Steps

1. Send a message that produces a streamed preview and a final text equal to that preview.
2. Finalization path reaches preview edit step.
3. Observe edit/failover behavior.

Expected

• One final visible message, no redundant resend.

Actual

• Before fix: message streamed and edited -> deleted -> resend same message again.
• After fix: finalize existing preview directly when no mutation is needed.

Evidence

Attach at least one:

• Failing test/log before + passing after

Human Verification (required)

What you personally verified (not just CI), and how:

• Verified scenarios:
  • Ran pnpm test src/telegram/bot-message-dispatch.test.ts (8/8 passing).
  • Verified new branches in src/telegram/bot-message-dispatch.test.ts:
    • skip edit when preview equals final
    • keep edit when formatting/buttons/linkPreview mutation is required
  • Live end-to-end Telegram run against real Bot API in this pass.
• Edge cases checked:
  • unchanged final text
  • markdown formatting pass required
  • inline buttons mutation
  • linkPreview=false mutation

Failure Recovery (if this breaks)

• How to disable/revert this change quickly:
  • Revert this commit, or temporarily set channels.telegram.streamMode=off.
• Files/config to restore:
  • src/telegram/bot-message-dispatch.ts
  • src/telegram/draft-stream.ts
• Known bad symptoms reviewers should watch for:
  • Unexpected duplicate message sends after finalization.

Greptile Summary

This PR adds a proactive optimization to prevent unnecessary Telegram API calls when finalizing streamed messages. It tracks the last successfully applied text in draft streams and short-circuits final edits when the content hasn't changed, while preserving edits for legitimate mutations (markdown formatting, inline buttons, linkPreview settings).

Key changes:

• Added lastAppliedText() method to TelegramDraftStream interface that tracks the last successfully applied text (stored only on successful API calls, not on failed edits)
• Added early-return logic in bot-message-dispatch.ts that compares preview text with final text and skips edit when no changes or mutations are needed
• Checks for formatting differences using renderTelegramHtmlText() to ensure markdown formatting passes still trigger edits
• Comprehensive test coverage for skip/keep scenarios including edge cases

This complements commit ac2ede5 which treats MESSAGE_NOT_MODIFIED errors as success at the API layer. Together they provide defense-in-depth: this PR prevents unnecessary calls, while ac2ede5 provides a safety net if they occur.

Confidence Score: 5/5

• This PR is safe to merge with minimal risk
• The implementation is well-designed with proper separation of concerns. The lastAppliedText tracking correctly distinguishes between attempted vs. successful edits, comprehensive test coverage validates all edge cases (formatting passes, button mutations, linkPreview changes), and the logic correctly handles the mismatch between plain-text draft previews and HTML-formatted final edits. The change is purely additive (early-return optimization) with no modification to existing success paths, and it works in tandem with existing error handling (ac2ede5) for defense-in-depth.
• No files require special attention

_{Last reviewed commit: 8a34945}

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