Avoid duplicate finalized Telegram previews

Author: assistant-ngalaiko[bot]

packages/pilegram/src/renderer.test.ts

@@ -6,23 +6,33 @@ import type { Writer } from "./writer.ts";
 const route: Route = { chatId: 1, threadId: 0 };
 
 /** A Writer stub that records provisional messages, edits, and final output. */
-function fakeWriter(opts?: { rejectHtml?: boolean }) {
+function fakeWriter(opts?: {
+  rejectHtml?: boolean;
+  rejectUnchanged?: boolean;
+}) {
   const sent: { text: string; html: boolean }[] = [];
   const edits: { id: number; text: string; html: boolean }[] = [];
   const deleted: number[] = [];
+  const messages = new Map<number, string>();
+  let nextId = 1;
   const writer = {
     async persist(text: string, extra?: { parse_mode?: string }) {
       const html = extra?.parse_mode === "HTML";
       if (html && opts?.rejectHtml)
         throw new Error("Bad Request: can't parse entities");
+      const message_id = nextId++;
       sent.push({ text, html });
-      return { message_id: sent.length };
+      messages.set(message_id, text);
+      return { message_id };
     },
     async editText(id: number, text: string, extra?: { parse_mode?: string }) {
       const html = extra?.parse_mode === "HTML";
       if (html && opts?.rejectHtml)
         throw new Error("Bad Request: can't parse entities");
+      if (opts?.rejectUnchanged && messages.get(id) === text)
+        throw new Error("Bad Request: message is not modified");
       edits.push({ id, text, html });
+      messages.set(id, text);
       return { message_id: id };
     },
     async deleteMessage(id: number) {
@@ -52,6 +62,39 @@ test("finalizes as Telegram HTML", async () => {
   expect(edits[0]!.text).toContain("<b>world</b>");
 });
 
+test("preserves a provisional message across continuation starts", async () => {
+  const { sent, edits, writer } = fakeWriter();
+  const r = new Renderer(writer, route);
+  r.onAgentStart();
+  r.onThinking("first attempt");
+  await flush();
+  r.onAgentStart(); // Pi continuation/retry, not a new user turn
+  r.onThinking(" continues");
+  r.onSettled("final answer");
+  await flush();
+
+  expect(sent).toHaveLength(1);
+  expect(edits).toHaveLength(1);
+  expect(edits[0]).toMatchObject({ id: 1, text: "final answer", html: true });
+});
+
+test("does not duplicate a final answer when the preview is already identical", async () => {
+  const { sent, edits, writer } = fakeWriter({ rejectUnchanged: true });
+  const finalized: { id: number; text: string }[] = [];
+  const r = new Renderer(writer, route, (id, text) =>
+    finalized.push({ id, text }),
+  );
+  r.onAgentStart();
+  r.onText("same answer");
+  await flush();
+  r.onSettled("same answer");
+  await flush();
+
+  expect(sent).toEqual([{ text: "same answer", html: false }]);
+  expect(edits).toHaveLength(0);
+  expect(finalized).toEqual([{ id: 1, text: "same answer" }]);
+});
+
 test("falls back to plain text when Telegram rejects the HTML", async () => {
   const { sent, writer } = fakeWriter({ rejectHtml: true });
   const r = new Renderer(writer, route);

packages/pilegram/src/renderer.ts

@@ -72,6 +72,13 @@ export class Renderer {
   }
 
   onAgentStart() {
+    // Pi emits agent_start for low-level continuations/retries within one user
+    // turn. Resetting here would orphan a live provisional Telegram message,
+    // which then can neither be finalized nor deleted.
+    if (this.running) {
+      this.log.debug("agent continuation; preserving preview");
+      return;
+    }
     this.clearTimers();
     this.running = true;
     this.acc = "";
@@ -270,9 +277,12 @@ export class Renderer {
     const preview = (this.preview ??= { latestText: text });
     preview.latestText = text;
     if (preview.id !== undefined) {
-      this.writer
-        .editText(preview.id, text)
-        .catch((e) => this.log.warn("preview update failed", errFields(e)));
+      this.writer.editText(preview.id, text).catch((e) => {
+        // Coalesced flushes can queue the same text twice. Telegram reports that
+        // as a 400, but it already has the desired state.
+        if (isMessageNotModified(e)) return;
+        this.log.warn("preview update failed", errFields(e));
+      });
       return;
     }
     if (preview.starting) return;
@@ -324,14 +334,23 @@ export class Renderer {
         await this.writer.editText(id, first, extra);
         this.onSent?.(id, first);
       } catch (e) {
-        if (!extra) throw e;
-        this.log.warn(
-          "HTML preview finalize rejected; retrying as plain text",
-          errFields(e),
-        );
-        const plain = htmlToPlain(first);
-        await this.writer.editText(id, plain);
-        this.onSent?.(id, plain);
+        // The streamed preview can already equal the final answer. Telegram's
+        // "message is not modified" is success for this state machine, not an
+        // HTML error. Retrying it as plain text then falling back to persist()
+        // created the duplicate message shown in the chat.
+        if (isMessageNotModified(e)) {
+          this.log.debug("preview already contains final text");
+          this.onSent?.(id, first);
+        } else {
+          if (!extra) throw e;
+          this.log.warn(
+            "HTML preview finalize rejected; retrying as plain text",
+            errFields(e),
+          );
+          const plain = htmlToPlain(first);
+          await this.writer.editText(id, plain);
+          this.onSent?.(id, plain);
+        }
       }
       for (const chunk of chunks.slice(1)) this.sendFinal(chunk, extra);
     } catch (e) {
@@ -394,6 +413,12 @@ export class Renderer {
   }
 }
 
+/** Telegram uses a 400 for a no-op edit; the requested state is already live. */
+function isMessageNotModified(e: unknown): boolean {
+  const message = e instanceof Error ? e.message : String(e);
+  return /message is not modified/i.test(message);
+}
+
 /** Strip Telegram-HTML tags and unescape entities, for the plain-text fallback. */
 function htmlToPlain(s: string): string {
   return s