fix(telegram): flush buffered final answer when reasoning delivery is skipped [AI-assisted] by amitgaur · Pull Request #53762 · openclaw/openclaw

amitgaur · 2026-03-24T15:16:57Z

Summary

Problem: When streaming: "partial" is enabled for Telegram and the model produces a turn with both a thinking block and a text block after a tool call, OpenClaw silently drops the text block (fixes [Bug]: streaming: partial drops text block when assistant turn contains [thinking, text] #53384).
Why it matters: Users receive the reasoning preview but never get the actual answer — a complete silent message loss.
What changed: Added a flushBufferedFinalAnswer() call before the early return in the segment delivery loop (bot-message-dispatch.ts) when info.kind === "final". A matching regression test was added.
What did NOT change: No behaviour change for non-final deliveries, non-reasoning payloads, or other channels.

Change Type (select all)

Bug fix

Scope (select all touched areas)

Integrations

Linked Issue/PR

Closes [Bug]: streaming: partial drops text block when assistant turn contains [thinking, text] #53384
This PR fixes a bug or regression

Root Cause / Regression History (if applicable)

Root cause: The segment delivery loop in deliverPayload (bot-message-dispatch.ts) processes reasoning and answer segments from a final payload. When a prior turn set activePreviewLifecycleByLane.reasoning = "complete" (because the answer segment processing at lines 678–683 saw reasoningLane.hasStreamedMessage = true), the reasoning delivery in the next turn returns "skipped" (lifecycle is "complete" → falls to sendPayload which fails). When reasoning is skipped, noteReasoningDelivered() is never called, so reasoningStatus stays "hinted". The answer segment then hits shouldBufferFinalAnswer() === true and is buffered. The loop exits via the if (segments.length > 0) { return; } early-return without flushing the buffer.
Missing detection / guardrail: The flushBufferedFinalAnswer() call was missing from this early-return path. It existed in the suppressedReasoningOnly path directly below (line 696) but not in the segment-processed path.
Prior context: The suppressedReasoningOnly branch already had the flush, making the omission in the segment branch the gap.
Why this regressed now: The buffering logic was added to handle the race between reasoning delivery and the final answer, but the "reasoning skipped" edge case after a tool boundary was not covered.

Regression Test Plan (if applicable)

Coverage level:
- Unit test
Target test: extensions/telegram/src/bot-message-dispatch.test.ts — "delivers final answer text when reasoning delivery is skipped in combined think-tag payload after tool boundary"
Scenario: Two-turn sequence: Turn 1 fires onReasoningStream then delivers an answer-only final (marking reasoning lifecycle "complete"). After onAssistantMessageStart, Turn 2 delivers <think>…</think>answer. The reasoning sendPayload is mocked to fail ({ delivered: false }), leaving the answer buffered. Without the fix the test fails (answer never delivered); with the fix it passes.
Why smallest reliable guardrail: Directly exercises the exact code path at the exact failure point with minimal setup.

User-visible / Behavior Changes

After a tool call in a Telegram conversation with streaming: partial and a reasoning-capable model, the assistant's text reply will now be delivered instead of silently dropped.

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: Linux
Runtime/container: Node 22 / Bun
Model/provider: Any reasoning model (e.g. claude-sonnet-4-6 with extended thinking)
Integration/channel: Telegram with streaming: "partial"
Relevant config: channels.telegram.streaming: "partial", reasoningLevel: "stream"

Steps

Configure Telegram channel with streaming: "partial" and a reasoning-capable model.
Send a message that triggers a tool call followed by a reply that includes both thinking and a text block.
Observe the Telegram conversation.

Expected

Reasoning block is shown as a preview (or skipped if already finalized).
Final text answer is delivered as a Telegram message.

Actual (before fix)

Reasoning block shown.
Text answer silently dropped — user receives no response.

Evidence

Failing test/log before + passing after

Test fails before fix:

Number of calls: 1
❯ extensions/telegram/src/bot-message-dispatch.test.ts:2493:33
    expect(editMessageTelegram).toHaveBeenCalledWith(123, 999, "final answer text", ...)
    AssertionError: expected "editMessageTelegram" to have been called with arguments: ...

Test passes after fix: Tests 1 passed (73)

Human Verification (required)

Verified scenarios: Two-turn reasoning+answer payload after tool boundary with skipped reasoning delivery; all 73 existing bot-message-dispatch tests still pass; pnpm check clean.
Edge cases checked: Single-turn reasoning (unaffected — goes through noteReasoningDelivered path, not the skipped path). suppressedReasoningOnly path (already had flush, unchanged).
What I did not verify: Live end-to-end on a real Telegram bot with a reasoning model.

Review Conversations

I replied to or resolved every bot review conversation I addressed in this PR.
I left unresolved only the conversations that still need reviewer or maintainer judgment.

Compatibility / Migration

Backward compatible? Yes
Config/env changes? No
Migration needed? No

Failure Recovery (if this breaks)

Revert commit fix(telegram): flush buffered final answer when reasoning delivery is skipped.
Known bad symptoms: if the flush itself throws, the final delivery would surface an error instead of silently dropping — this is strictly better than the previous silent drop.

Risks and Mitigations

Risk: flushBufferedFinalAnswer() is now called even when the buffer is empty (it returns early if takeBufferedFinalAnswer() returns undefined), so there is no functional risk for the normal (non-bug) path.
- Mitigation: flushBufferedFinalAnswer is a no-op when no answer is buffered.

AI-Assisted PR Checklist

Built with Claude Code (claude-sonnet-4-6)
Fully tested — pnpm test:extension telegram (1020 passed), pnpm check, pnpm build all green
I understand what the code does — root cause traced through reasoningStepState, activePreviewLifecycleByLane, flushBufferedFinalAnswer, and deliverLaneText call chain
Greptile summary reviewed — informational only, no action items

greptile-apps · 2026-03-24T15:18:55Z

Greptile Summary

This PR fixes a silent message-loss bug in the Telegram integration where, after a tool call in a streaming: "partial" session with a reasoning-capable model, the assistant's text reply was silently dropped when the reasoning delivery was "skipped" (lifecycle already "complete" from the prior turn).

Root cause: The segment delivery loop in deliverPayload would buffer the answer segment whenever shouldBufferFinalAnswer() was true (reasoning status still "hinted" because noteReasoningDelivered() was never called for a skipped reasoning segment), then exit via the if (segments.length > 0) { return; } early-return without flushing that buffer.

Fix: A single await flushBufferedFinalAnswer() call, guarded by info.kind === "final", is inserted immediately before the early return. This matches the identical pattern already present in the suppressedReasoningOnly path and the canSendAsIs/sendPayload paths directly below. flushBufferedFinalAnswer is safely idempotent (no-op when the buffer is empty), so there is zero risk of double-delivery on the normal path.

Test: A focused regression test reproduces the exact two-turn tool-boundary scenario — Turn 1 finalises reasoning lifecycle to "complete", Turn 2 sends a combined <think>…</think>answer payload, reasoning delivery is mocked to fail, and the test asserts the buffered final answer text is delivered. All 73 existing dispatch tests continue to pass.

Key changes:

bot-message-dispatch.ts — adds flushBufferedFinalAnswer() before early-return in the segment branch (lines 692–694)
bot-message-dispatch.test.ts — adds regression test covering the "reasoning skipped after tool boundary" path

Confidence Score: 5/5

Safe to merge — minimal one-line fix with a no-op fallback, mirroring existing patterns already proven correct in sibling branches.
The fix is a single targeted call that is already used identically in every other exit-path of the same function. flushBufferedFinalAnswer returns early when the buffer is empty, so there is no risk of double-delivery or side-effects on non-bug paths. The regression test faithfully reproduces the exact failure mode described in the root cause. No interface changes, no new permissions, no config changes, and all 73 existing tests pass.
No files require special attention.

_{Reviews (1): Last reviewed commit: "fix(telegram): flush buffered final answ..." | Re-trigger Greptile}

amitgaur · 2026-03-24T15:29:16Z

Code review

No issues found. Checked for bugs and CLAUDE.md compliance.

🤖 Generated with Claude Code

_{- If this code review was useful, please react with 👍. Otherwise, react with 👎.}

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 38d385d658

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

chatgpt-codex-connector · 2026-04-11T03:52:17Z

+            if (info.kind === "final") {
+              await flushBufferedFinalAnswer();
+            }


Emit message-sent hook when flushing buffered final answers

The new final-segment early-return branch calls flushBufferedFinalAnswer() and then exits, but this flush path drops the deliverLaneText result and never runs emitPreviewFinalizedHook(...) when the buffered answer is finalized via preview edit. In streaming: "partial" flows with sessionKeyForInternalHooks, the user gets the Telegram answer, but the internal message:sent hook is skipped for that turn, unlike the normal segment-delivery path.

Useful? React with 👍 / 👎.

… skipped

amitgaur · 2026-04-11T04:12:37Z

Rebased onto the latest main, resolved the changelog conflict, and reran the targeted Telegram regression test locally:

pnpm test -- extensions/telegram/src/bot-message-dispatch.test.ts

Result: 1 test file passed, 74 tests passed.

This PR is now mergeable and ready for maintainer review. Relevant reviewers for this area appear to be @vincentkoc and @obviyus.

openclaw-barnacle · 2026-04-29T04:42:39Z

This pull request has been automatically marked as stale due to inactivity.
Please add updates or it will be closed.

clawsweeper · 2026-04-29T05:48:54Z

Thanks for the context here. I swept through the related work, and this is now duplicate or superseded.

This PR has the right visible Telegram fix direction, but it is superseded by the open hook-preserving replacement at #83670, which carries the same final-answer flush plus the missing hook/transcript preservation.

Canonical path: Close this branch and review or land the hook-preserving replacement PR at #83670, or an equivalent patch with the same flush, hook, transcript, and regression coverage.

So I’m closing this here and keeping the remaining discussion on #83670.

Review details

Best possible solution:

Close this branch and review or land the hook-preserving replacement PR at #83670, or an equivalent patch with the same flush, hook, transcript, and regression coverage.

Do we have a high-confidence way to reproduce the issue?

Yes, from source inspection. Current main can buffer a final answer after a hinted/skipped reasoning segment and then return from the segmented-final branch without draining that buffer.

Is this the best way to solve the issue?

No, this branch is not the best merge target anymore. The missing flush is the right narrow fix, but the active replacement preserves the normal preview-finalized hook and transcript behavior too.

Security review:

Security review cleared: The diff only changes Telegram dispatch control flow, a colocated test, and changelog text; it adds no dependency, workflow, permission, secret, or supply-chain surface.

What I checked:

current-main-buffered-flush-drops-result: Current main's flushBufferedFinalAnswer awaits deliverFinalAnswerText but discards the LaneDeliveryResult, so a flushed preview-finalized answer cannot reach emitPreviewFinalizedHook from this helper. (extensions/telegram/src/bot-message-dispatch.ts:1384, 1c3ff34d752f)
current-main-segmented-return-still-needs-fix: The segmented delivery branch on current main tracks block media and returns when segments exist; there is still no final buffered-answer drain at that early return in main. (extensions/telegram/src/bot-message-dispatch.ts:1469, 1c3ff34d752f)
hook-contract-source: Normal final segment delivery calls emitPreviewFinalizedHook, which emits the internal message:sent hook and mirrors transcript text for preview-finalized deliveries. (extensions/telegram/src/bot-message-dispatch.ts:1176, 1c3ff34d752f)
buffer-state-source: The reasoning coordinator buffers a final answer while reasoning is hinted and only releases it through takeBufferedFinalAnswer, matching the skipped-reasoning reproduction path. (extensions/telegram/src/reasoning-lane-coordinator.ts:118, 1c3ff34d752f)
this-pr-diff: This PR adds a guarded flushBufferedFinalAnswer call before the segmented early return and a visible-delivery regression test, but does not change the helper to emit the preview-finalized hook result. (extensions/telegram/src/bot-message-dispatch.ts:703, b25e563bcb94)
superseding-pr-diff: The replacement PR captures the deliverFinalAnswerText result, passes it to emitPreviewFinalizedHook, adds the same final-return flush, and adds a hook/transcript regression test. (extensions/telegram/src/bot-message-dispatch.ts:1318, 3a8580d74a47)

Likely related people:

obviyus: Merged Telegram partial-stream preview and reasoning/answer lane split work that defines the dispatch path touched by this PR. (role: Telegram streaming lane feature owner; confidence: high; commits: 583844ecf6c1, ab256b8ec71f; files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/reasoning-lane-coordinator.ts, extensions/telegram/src/bot-message-dispatch.test.ts)
vincentkoc: Authored the merged Telegram direct-delivery message:sent hook parity work, and the unresolved finding is about preserving that hook path during buffered final flushes. (role: hook contract contributor; confidence: high; commits: 817fa5462b9f, 017b38954991, 7b88249c9e03; files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/bot/delivery.replies.ts)
Ayaan Zaidi: Current checkout blame on the dispatcher and reasoning coordinator points the reviewed code snapshot through Ayaan Zaidi's recent Telegram commit, though the useful ownership signal overlaps with @obviyus history. (role: recent current-path carrier; confidence: medium; commits: 3fb5b4bec94d; files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/reasoning-lane-coordinator.ts, extensions/telegram/src/bot-message-dispatch.test.ts)

Codex review notes: model gpt-5.5, reasoning high; reviewed against 1c3ff34d752f.

clawsweeper · 2026-04-29T16:57:35Z

Codex review: found issues before merge.

What this changes:

This PR adds a Telegram dispatcher flush for buffered final-answer text before the segmented final-delivery early return, adds a regression test for skipped reasoning after a tool boundary, and adds a changelog fix entry.

Maintainer follow-up before merge:

This is already an open implementation PR for a narrow, real Telegram message-loss bug, but it has a specific unresolved hook-preservation review finding and likely needs maintainer or author follow-up on the branch rather than a separate automated replacement branch.

Review findings:

[P2] Emit the hook when flushing buffered final answers — extensions/telegram/src/bot-message-dispatch.ts:703

Review details

Best possible solution:

Land this PR or an equivalent Telegram-owned patch after flushBufferedFinalAnswer() returns or emits the LaneDeliveryResult through the same preview-finalized hook path as normal final segment delivery, while preserving current-main compaction-boundary handling and keeping the change scoped to Telegram dispatch, focused tests, and the user-facing changelog entry.

Full review comments:

[P2] Emit the hook when flushing buffered final answers — extensions/telegram/src/bot-message-dispatch.ts:703
The new segmented-final early return calls flushBufferedFinalAnswer() and exits, but that helper discards the deliverLaneText() result. When the buffered answer finalizes an existing preview, Telegram shows the answer but emitPreviewFinalizedHook(...) is never run, so sessionKeyForInternalHooks flows miss the internal message:sent hook unlike normal final segment delivery. Capture the result and route preview-finalized deliveries through the hook before resetting state.
Confidence: 0.88

Overall correctness: patch is incorrect
Overall confidence: 0.88

Acceptance criteria:

pnpm test extensions/telegram/src/bot-message-dispatch.test.ts
pnpm test extensions/telegram

What I checked:

current-main-segmented-final-return-still-lacks-flush: On current main, the segmented delivery branch clears pendingCompactionReplayBoundary for final payloads and returns without calling flushBufferedFinalAnswer(), so the PR's intended behavior is not already implemented. (extensions/telegram/src/bot-message-dispatch.ts:943, e46dccb35374)
buffered-final-answer-can-remain-pending: The reasoning step state buffers final answer text while reasoning is only hinted; it is cleared only by takeBufferedFinalAnswer() or resetForNextStep(), which matches the reported missing-flush path. (extensions/telegram/src/reasoning-lane-coordinator.ts:112, e46dccb35374)
normal-final-segment-emits-preview-finalized-hook: Normal final segment delivery captures the LaneDeliveryResult from deliverLaneText() and passes it to emitPreviewFinalizedHook(), which emits the internal hook when the result is preview-finalized. (extensions/telegram/src/bot-message-dispatch.ts:925, e46dccb35374)
flush-helper-currently-drops-delivery-result: flushBufferedFinalAnswer() currently awaits deliverLaneText() but discards its LaneDeliveryResult, so a new call from the PR's early-return branch would not emit message:sent when the buffered answer finalizes a preview. (extensions/telegram/src/bot-message-dispatch.ts:892, e46dccb35374)
hook-contract-covered-by-existing-test: Current tests already assert that a final answer which stays in preview emits the internal message:sent hook, which is the contract the PR's new flush path should preserve. (extensions/telegram/src/bot-message-dispatch.test.ts:1077, e46dccb35374)
latest-release-also-lacks-proposed-flush: Tag v2026.4.26 shows the same segmented final return without a flush call, so the proposed user-visible fix was not already shipped in the latest release. (extensions/telegram/src/bot-message-dispatch.ts:943, be8c24633aaa)

Likely related people:

vincentkoc: Changelog history credits @vincentkoc for bridging Telegram delivery into internal message:sent hooks, and the outstanding review concern is specifically about preserving that hook contract on the new flush path. (role: hook-path owner / recent maintainer; confidence: high; commits: ad2516b1c876; files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/bot/delivery.replies.ts, docs/automation/hooks.md)
steipete: Current-main blame and recent path history for the dispatcher, lane deliverer, and reasoning coordinator point to Peter Steinberger's latest snapshots, and the latest release tag containing this behavior is Peter-authored. (role: recent maintainer / release snapshot owner; confidence: medium; commits: 34d11d57579d, be8c24633aaa, 204ef7f1c45b; files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/reasoning-lane-coordinator.ts, extensions/telegram/src/lane-delivery-text-deliverer.ts)
obviyus: Changelog history credits @obviyus across Telegram streaming, reasoning lane, preview finalization, and tool-boundary behavior, and the PR discussion identified him as a relevant reviewer for this area. (role: adjacent Telegram streaming contributor / reviewer; confidence: medium; commits: [PR fix: split telegram reasoning and answer draft streams #20774](PR fix: split telegram reasoning and answer draft streams #20774), [PR fix(telegram): avoid duplicate preview bubbles in partial stream mode #18956](PR fix(telegram): avoid duplicate preview bubbles in partial stream mode #18956), [PR [Bug]: telegram live stream bug #17883](PR [Bug]: telegram live stream bug #17883); files: extensions/telegram/src/bot-message-dispatch.ts, extensions/telegram/src/draft-stream.ts, extensions/telegram/src/reasoning-lane-coordinator.ts)

Remaining risk / open question:

The PR branch is based on older main while current main has added pendingCompactionReplayBoundary handling in the same segmented-final return path; the final patch should preserve both behaviors during rebase or merge.
The added regression checks user-visible answer delivery, but the unresolved hook path needs explicit coverage with sessionKeyForInternalHooks so preview-finalized buffered answers still emit message:sent.

Codex review notes: model gpt-5.5, reasoning high; reviewed against e46dccb35374.

bpconnor3-r2 · 2026-05-18T14:33:40Z

Adding downstream behavior evidence from an R2/OpenClaw production-style droplet because this PR is the canonical fix path and #83616 was closed as a duplicate of it.

Environment:

OpenClaw npm global install: 2026.5.12
Runtime: systemd user gateway on Linux, Telegram channel enabled, direct-message visible replies set to automatic
Patch applied live to the installed bundle with the same guard shape as this PR: when segmented delivery handles a final payload, call flushBufferedFinalAnswer() before the segments.length > 0 early return

Observed failure mode before the patch:

Final output split into reasoning/answer lanes could leave the visible answer buffered after the reasoning segment was handled/skipped.
The segmented-delivery branch returned before draining the buffered final answer, so the model completed but Telegram auto-delivery did not send the visible answer.

After-fix proof:

Ran a controlled Telegram ingress through the live R2 gateway into an allowlisted real direct Telegram chat.
Prompt asked for the exact final text R2_AUTO_OK_SIM.
The model final was R2_AUTO_OK_SIM and no message.action send tool was used.
The Telegram sent-message cache recorded the outbound Bot API delivery at 2026-05-18T12:45:28Z with message id 27371.
A follow-up healthcheck showed the gateway live and the hotfix present: curl /health returned {"ok":true,"status":"live"}, systemd user service was running, and the hotfix checker reported OpenClaw Telegram auto-delivery hotfix present.

Additional validation I ran while preparing #83616:

Equivalent upstream patch against current main passed the targeted dispatcher suite:
OPENCLAW_VITEST_INCLUDE_FILE=/tmp/openclaw-telegram-include.json node scripts/run-vitest.mjs run --config test/vitest/vitest.extension-telegram.config.ts
Result: extensions/telegram/src/bot-message-dispatch.test.ts passed, 67 tests.
Downstream durable guard merged in bpconnor3-r2/R2-openclaw#254, including an idempotent installed-bundle checker and healthcheck integration so future OpenClaw upgrades flag this regression if it reappears.

This is not a screenshot/recording, but it is after-fix evidence from a live Telegram outbound path, with private chat details redacted.

bpconnor3-r2 · 2026-05-18T15:47:58Z

I opened a hook-preserving replacement branch/PR here: #83670

Why: this keeps the same buffered-final-answer fix direction, but addresses the unresolved review finding on this PR. The replacement flushBufferedFinalAnswer() captures the LaneDeliveryResult from deliverFinalAnswerText() and routes preview-finalized deliveries through the same emitPreviewFinalizedHook(...) path as ordinary final segment delivery, so internal message:sent hooks and transcript mirroring stay consistent.

Validation on the replacement branch:

git diff --check
OPENCLAW_VITEST_INCLUDE_FILE=/tmp/openclaw-telegram-include-v2.json node scripts/run-vitest.mjs run --config test/vitest/vitest.extension-telegram.config.ts
Result: extensions/telegram/src/bot-message-dispatch.test.ts passed, 68 tests

The R2 live Telegram proof remains here: #53762 (comment)

clawsweeper · 2026-05-19T01:16:36Z

ClawSweeper applied the proposed close for this PR.

Action: closed this PR.
Close reason: duplicate or superseded.
Evidence: durable ClawSweeper review.

openclaw-barnacle Bot added channel: telegram Channel integration: telegram size: S labels Mar 24, 2026

amitgaur changed the title ~~fix(telegram): flush buffered final answer when reasoning delivery is skipped~~ fix(telegram): flush buffered final answer when reasoning delivery is skipped [AI-assisted] Mar 24, 2026

amitgaur force-pushed the fix/telegram-reasoning-answer-drop branch from 7ea0c67 to b4bc5b7 Compare March 24, 2026 16:19

amitgaur force-pushed the fix/telegram-reasoning-answer-drop branch from b4bc5b7 to 38d385d Compare April 11, 2026 03:48

chatgpt-codex-connector Bot reviewed Apr 11, 2026

View reviewed changes

amitgaur added 2 commits April 10, 2026 20:59

fix(telegram): flush buffered final answer when reasoning delivery is…

10046fb

… skipped

fix(telegram): flush buffered final answer when reasoning delivery is…

b25e563

… skipped

amitgaur force-pushed the fix/telegram-reasoning-answer-drop branch from 38d385d to b25e563 Compare April 11, 2026 04:00

openclaw-barnacle Bot added the stale Marked as stale due to inactivity label Apr 29, 2026

openclaw-barnacle Bot removed the stale Marked as stale due to inactivity label Apr 30, 2026

clawsweeper Bot added the mantis: telegram-visible-proof Mantis should capture Telegram visible proof. label May 11, 2026

openclaw-barnacle Bot added the triage: needs-real-behavior-proof Candidate: external PR needs after-fix proof from a real setup. label May 11, 2026

clawsweeper Bot mentioned this pull request May 18, 2026

Flush buffered Telegram finals after segmented delivery #83616

Closed

bpconnor3-r2 mentioned this pull request May 18, 2026

fix: Preserve Telegram hooks when flushing buffered finals #83670

Open

clawsweeper Bot closed this May 19, 2026

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

fix(telegram): flush buffered final answer when reasoning delivery is skipped [AI-assisted]#53762

fix(telegram): flush buffered final answer when reasoning delivery is skipped [AI-assisted]#53762
amitgaur wants to merge 2 commits into
openclaw:mainfrom
amitgaur:fix/telegram-reasoning-answer-drop

amitgaur commented Mar 24, 2026 •

edited

Loading

Uh oh!

greptile-apps Bot commented Mar 24, 2026

Uh oh!

amitgaur commented Mar 24, 2026

Uh oh!

chatgpt-codex-connector Bot left a comment

Uh oh!

chatgpt-codex-connector Bot Apr 11, 2026

Uh oh!

amitgaur commented Apr 11, 2026

Uh oh!

openclaw-barnacle Bot commented Apr 29, 2026

Uh oh!

clawsweeper Bot commented Apr 29, 2026 •

edited

Loading

Uh oh!

clawsweeper Bot commented Apr 29, 2026

Uh oh!

bpconnor3-r2 commented May 18, 2026

Uh oh!

bpconnor3-r2 commented May 18, 2026

Uh oh!

clawsweeper Bot commented May 19, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Uh oh!

Conversation

amitgaur commented Mar 24, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Change Type (select all)

Scope (select all touched areas)

Linked Issue/PR

Root Cause / Regression History (if applicable)

Regression Test Plan (if applicable)

User-visible / Behavior Changes

Security Impact (required)

Repro + Verification

Environment

Steps

Expected

Actual (before fix)

Evidence

Human Verification (required)

Review Conversations

Compatibility / Migration

Failure Recovery (if this breaks)

Risks and Mitigations

AI-Assisted PR Checklist

Uh oh!

greptile-apps Bot commented Mar 24, 2026

Greptile Summary

Confidence Score: 5/5

Uh oh!

amitgaur commented Mar 24, 2026

Code review

Uh oh!

chatgpt-codex-connector Bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector Bot Apr 11, 2026

Choose a reason for hiding this comment

Uh oh!

amitgaur commented Apr 11, 2026

Uh oh!

openclaw-barnacle Bot commented Apr 29, 2026

Uh oh!

clawsweeper Bot commented Apr 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

clawsweeper Bot commented Apr 29, 2026

Uh oh!

bpconnor3-r2 commented May 18, 2026

Uh oh!

bpconnor3-r2 commented May 18, 2026

Uh oh!

clawsweeper Bot commented May 19, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

amitgaur commented Mar 24, 2026 •

edited

Loading

clawsweeper Bot commented Apr 29, 2026 •

edited

Loading