fix(telegram): clean up split reasoning previews

ly-wang19 · steipete · commit e60a700a27d4 · 2026-07-10T20:25:43.000-04:00
diff --git a/extensions/telegram/src/bot-message-dispatch.test.ts b/extensions/telegram/src/bot-message-dispatch.test.ts
@@ -4892,6 +4892,37 @@ describe("dispatchTelegramMessage draft streaming", () => {
     expect(updates.join("\n")).not.toContain("CheckingReading");
   });
 
+  it("repositions split reasoning before deleting the prior preview", async () => {
+    const answerDraftStream = createDraftStream(2001);
+    const reasoningDraftStream = createSequencedDraftStream(3001);
+    createTelegramDraftStream
+      .mockImplementationOnce(() => answerDraftStream)
+      .mockImplementationOnce(() => reasoningDraftStream);
+    let replacementMessageId: number | undefined;
+    dispatchReplyWithBufferedBlockDispatcher.mockImplementation(async ({ replyOptions }) => {
+      await replyOptions?.onReasoningStream?.({ text: "<think>First thought</think>" });
+      await replyOptions?.onReasoningEnd?.();
+      await replyOptions?.onReasoningStream?.({ text: "<think>Second thought</think>" });
+      replacementMessageId = reasoningDraftStream.messageId();
+      return { queuedFinal: false };
+    });
+
+    await dispatchWithContext({ context: createReasoningStreamContext() });
+
+    expect(reasoningDraftStream.update).toHaveBeenNthCalledWith(1, "🧠 _First thought_");
+    expect(reasoningDraftStream.update).toHaveBeenNthCalledWith(2, "🧠 _Second thought_");
+    expect(reasoningDraftStream.rotateToNewMessageDeferringDelete).toHaveBeenCalledTimes(1);
+    expect(reasoningDraftStream.forceNewMessage).not.toHaveBeenCalled();
+    expect(reasoningDraftStream.clear).toHaveBeenCalledTimes(1);
+    expect(
+      reasoningDraftStream.rotateToNewMessageDeferringDelete.mock.invocationCallOrder[0],
+    ).toBeLessThan(reasoningDraftStream.update.mock.invocationCallOrder[1]);
+    expect(reasoningDraftStream.update.mock.invocationCallOrder[1]).toBeLessThan(
+      reasoningDraftStream.clear.mock.invocationCallOrder[0],
+    );
+    expect(replacementMessageId).toBe(3002);
+  });
+
   it("streams reasoning from configured defaults", async () => {
     const { answerDraftStream, reasoningDraftStream } = setupDraftStreams({
       answerMessageId: 2001,
diff --git a/extensions/telegram/src/bot-message-dispatch.ts b/extensions/telegram/src/bot-message-dispatch.ts
@@ -1287,6 +1287,12 @@ export const dispatchTelegramMessage = async ({
       lastAnswerBlockButtons = undefined;
     }
   };
+  const repositionDraftLaneForNewMessage = (lane: DraftLaneState) => {
+    // Reposition instead of delete-then-repost: the replacement must land
+    // before deferred cleanup or Telegram can jump and retain a stale preview.
+    lane.stream?.rotateToNewMessageDeferringDelete();
+    resetDraftLaneState(lane);
+  };
   const rotateLaneForNewMessage = async (lane: DraftLaneState) => {
     if (!lane.hasStreamedMessage && typeof lane.stream?.messageId() !== "number") {
       resetDraftLaneState(lane);
@@ -1306,16 +1312,7 @@ export const dispatchTelegramMessage = async ({
     if (!activeAnswerDraftIsToolProgressOnly) {
       return false;
     }
-    // Reposition, don't delete-then-repost: rewind so the replacement message
-    // sends below, and defer the tool-progress window's delete until after it
-    // lands. Deleting first (clear) scroll-jumps the client when a durable 🧠
-    // was posted between the window and the replacement (the on-off jump).
-    if (answerLane.stream?.rotateToNewMessageDeferringDelete) {
-      answerLane.stream.rotateToNewMessageDeferringDelete();
-    } else {
-      answerLane.stream?.forceNewMessage();
-    }
-    resetDraftLaneState(answerLane);
+    repositionDraftLaneForNewMessage(answerLane);
     suppressProgressDraftState();
     rotateAnswerLaneWhenQueuedBlocksSettle = false;
     return true;
@@ -2693,8 +2690,7 @@ export const dispatchTelegramMessage = async ({
                     ? (payload) =>
                         enqueueDraftLaneEvent(async () => {
                           if (splitReasoningOnNextStream) {
-                            reasoningLane.stream?.forceNewMessage();
-                            resetDraftLaneState(reasoningLane);
+                            repositionDraftLaneForNewMessage(reasoningLane);
                             splitReasoningOnNextStream = false;
                           }
                           await ingestDraftLaneSegments(payload, true);
