@llblab/pi-telegram 0.2.8 → 0.2.10

package/tests/replies.test.ts

@@ -1,239 +1,19 @@
 /**
- * Regression tests for the Telegram replies domain
- * Covers preview decisions, rendered-message delivery, and plain or markdown reply sending in one suite
+ * Regression tests for Telegram reply delivery helpers
+ * Covers rendered-message transport, chunk delivery, and plain or markdown final reply sending
  */
 
 import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  buildTelegramPreviewFinalText,
-  buildTelegramPreviewFlushText,
   buildTelegramReplyTransport,
-  clearTelegramPreview,
   editTelegramRenderedMessage,
-  finalizeTelegramMarkdownPreview,
-  finalizeTelegramPreview,
-  flushTelegramPreview,
   sendTelegramMarkdownReply,
   sendTelegramPlainReply,
   sendTelegramRenderedChunks,
-  shouldUseTelegramDraftPreview,
 } from "../lib/replies.ts";
 
-function createPreviewRuntimeHarness(state?: {
-  mode: "draft" | "message";
-  draftId?: number;
-  messageId?: number;
-  pendingText: string;
-  lastSentText: string;
-  flushTimer?: ReturnType<typeof setTimeout>;
-}) {
-  let previewState = state;
-  let draftSupport: "unknown" | "supported" | "unsupported" = "unknown";
-  let nextDraftId = 10;
-  const events: string[] = [];
-  return {
-    events,
-    getState: () => previewState,
-    getDraftSupport: () => draftSupport,
-    setDraftSupport: (support: "unknown" | "supported" | "unsupported") => {
-      draftSupport = support;
-    },
-    deps: {
-      getState: () => previewState,
-      setState: (nextState: typeof previewState) => {
-        previewState = nextState;
-      },
-      clearScheduledFlush: (nextState: NonNullable<typeof previewState>) => {
-        if (!nextState.flushTimer) return;
-        clearTimeout(nextState.flushTimer);
-        nextState.flushTimer = undefined;
-        events.push("clear-timer");
-      },
-      maxMessageLength: 5,
-      renderPreviewText: (markdown: string) => markdown.replaceAll("*", ""),
-      getDraftSupport: () => draftSupport,
-      setDraftSupport: (support: "unknown" | "supported" | "unsupported") => {
-        draftSupport = support;
-      },
-      allocateDraftId: () => nextDraftId++,
-      sendDraft: async (chatId: number, draftId: number, text: string) => {
-        events.push(`draft:${chatId}:${draftId}:${text}`);
-      },
-      sendMessage: async (chatId: number, text: string) => {
-        events.push(`send:${chatId}:${text}`);
-        return { message_id: 77 };
-      },
-      editMessageText: async (
-        chatId: number,
-        messageId: number,
-        text: string,
-      ) => {
-        events.push(`edit:${chatId}:${messageId}:${text}`);
-      },
-      renderTelegramMessage: (text: string, options?: { mode?: string }) => [
-        { text: `${options?.mode ?? "plain"}:${text}` },
-      ],
-      sendRenderedChunks: async (
-        chatId: number,
-        chunks: Array<{ text: string }>,
-      ) => {
-        events.push(
-          `render-send:${chatId}:${chunks.map((chunk) => chunk.text).join("|")}`,
-        );
-        return 88;
-      },
-      editRenderedMessage: async (
-        chatId: number,
-        messageId: number,
-        chunks: Array<{ text: string }>,
-      ) => {
-        events.push(
-          `render-edit:${chatId}:${messageId}:${chunks.map((chunk) => chunk.text).join("|")}`,
-        );
-        return messageId;
-      },
-    },
-  };
-}
-
-test("Reply previews build flush text only when the preview changed", () => {
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "draft",
-        pendingText: "**hello**",
-        lastSentText: "",
-      },
-      maxMessageLength: 4096,
-      renderPreviewText: (markdown) => markdown.replaceAll("*", ""),
-    }),
-    "hello",
-  );
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "draft",
-        pendingText: "**hello**",
-        lastSentText: "hello",
-      },
-      maxMessageLength: 4096,
-      renderPreviewText: (markdown) => markdown.replaceAll("*", ""),
-    }),
-    undefined,
-  );
-});
-
-test("Reply previews truncate long flush text and compute final text fallback", () => {
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "message",
-        pendingText: "abcdef",
-        lastSentText: "",
-      },
-      maxMessageLength: 3,
-      renderPreviewText: (markdown) => markdown,
-    }),
-    "abc",
-  );
-  assert.equal(
-    buildTelegramPreviewFinalText({
-      mode: "message",
-      pendingText: "   ",
-      lastSentText: "saved",
-    }),
-    "saved",
-  );
-  assert.equal(
-    buildTelegramPreviewFinalText({
-      mode: "message",
-      pendingText: "   ",
-      lastSentText: "   ",
-    }),
-    undefined,
-  );
-});
-
-test("Reply previews use drafts unless support is explicitly disabled", () => {
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "unknown" }),
-    true,
-  );
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "supported" }),
-    true,
-  );
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "unsupported" }),
-    false,
-  );
-});
-
-test("Reply preview runtime prefers draft updates and can clear draft previews", async () => {
-  const harness = createPreviewRuntimeHarness({
-    mode: "draft",
-    pendingText: "**hello**",
-    lastSentText: "",
-    flushTimer: setTimeout(() => {}, 1000),
-  });
-  await flushTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["draft:7:10:hello"]);
-  assert.equal(harness.getState()?.mode, "draft");
-  assert.equal(harness.getState()?.draftId, 10);
-  assert.equal(harness.getState()?.lastSentText, "hello");
-  assert.equal(harness.getDraftSupport(), "supported");
-  await clearTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["draft:7:10:hello", "draft:7:10:"]);
-  assert.equal(harness.getState(), undefined);
-});
-
-test("Reply preview runtime falls back to editable messages when draft delivery fails", async () => {
-  const harness = createPreviewRuntimeHarness({
-    mode: "draft",
-    pendingText: "abcdef",
-    lastSentText: "",
-  });
-  harness.deps.sendDraft = async () => {
-    throw new Error("draft unsupported");
-  };
-  await flushTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["send:7:abcde"]);
-  assert.equal(harness.getState()?.mode, "message");
-  assert.equal(harness.getState()?.messageId, 77);
-  assert.equal(harness.getDraftSupport(), "unsupported");
-});
-
-test("Reply preview runtime finalizes plain and markdown previews", async () => {
-  const plainHarness = createPreviewRuntimeHarness({
-    mode: "message",
-    messageId: 44,
-    pendingText: "done",
-    lastSentText: "",
-  });
-  plainHarness.setDraftSupport("unsupported");
-  assert.equal(await finalizeTelegramPreview(7, plainHarness.deps), true);
-  assert.deepEqual(plainHarness.events, ["edit:7:44:done"]);
-  assert.equal(plainHarness.getState(), undefined);
-  const markdownHarness = createPreviewRuntimeHarness({
-    mode: "message",
-    messageId: 55,
-    pendingText: "done",
-    lastSentText: "",
-  });
-  markdownHarness.setDraftSupport("unsupported");
-  assert.equal(
-    await finalizeTelegramMarkdownPreview(7, "**done**", markdownHarness.deps),
-    true,
-  );
-  assert.deepEqual(markdownHarness.events, [
-    "edit:7:55:done",
-    "render-edit:7:55:markdown:**done**",
-  ]);
-  assert.equal(markdownHarness.getState(), undefined);
-});
-
 test("Reply transport forwards send and edit operations through delivery helpers", async () => {
   const events: string[] = [];
   const transport = buildTelegramReplyTransport({

package/tests/turns.test.ts

@@ -11,6 +11,7 @@ import {
   buildTelegramTurnPrompt,
   formatTelegramTurnStatusSummary,
   truncateTelegramQueueSummary,
+  updateTelegramPromptTurnText,
 } from "../lib/turns.ts";
 
 test("Turn helpers truncate queue summaries predictably", () => {
@@ -69,6 +70,120 @@ test("Turn helpers summarize text and attachment-only turns", () => {
   );
 });
 
+test("Turn helpers update queued prompt text for edited Telegram messages", () => {
+  const turn = {
+    kind: "prompt" as const,
+    chatId: 99,
+    replyToMessageId: 10,
+    sourceMessageIds: [10],
+    queueOrder: 1,
+    queueLane: "default" as const,
+    laneOrder: 1,
+    queuedAttachments: [],
+    content: [{ type: "text" as const, text: "[telegram] old" }],
+    historyText: "old",
+    statusSummary: "old",
+  };
+  const updated = updateTelegramPromptTurnText({
+    turn,
+    telegramPrefix: "[telegram]",
+    rawText: "new edited message",
+  });
+  assert.equal(updated.content[0]?.type, "text");
+  assert.equal(
+    (updated.content[0] as { type: "text"; text: string }).text,
+    "[telegram] new edited message",
+  );
+  assert.equal(updated.historyText, "new edited message");
+  assert.equal(updated.statusSummary, "new edited message");
+  assert.notEqual(updated, turn);
+});
+
+test("Turn helpers preserve queued prompt attachments when captions are edited", () => {
+  const turn = {
+    kind: "prompt" as const,
+    chatId: 99,
+    replyToMessageId: 10,
+    sourceMessageIds: [10],
+    queueOrder: 1,
+    queueLane: "default" as const,
+    laneOrder: 1,
+    queuedAttachments: [],
+    content: [
+      {
+        type: "text" as const,
+        text:
+          "[telegram] old caption\n\n" +
+          "Telegram attachments were saved locally:\n" +
+          "- /tmp/demo.png\n" +
+          "- /tmp/report.txt",
+      },
+      { type: "image" as const, data: "abc", mimeType: "image/png" },
+    ],
+    historyText: "old caption\nAttachments:\n- /tmp/demo.png\n- /tmp/report.txt",
+    statusSummary: "old caption",
+  };
+  const updated = updateTelegramPromptTurnText({
+    turn,
+    telegramPrefix: "[telegram]",
+    rawText: "new caption",
+  });
+  assert.equal(
+    (updated.content[0] as { type: "text"; text: string }).text,
+    "[telegram] new caption\n\n" +
+      "Telegram attachments were saved locally:\n" +
+      "- /tmp/demo.png\n" +
+      "- /tmp/report.txt",
+  );
+  assert.deepEqual(updated.content[1], turn.content[1]);
+  assert.equal(
+    updated.historyText,
+    "new caption\nAttachments:\n- /tmp/demo.png\n- /tmp/report.txt",
+  );
+  assert.equal(updated.statusSummary, "new caption");
+});
+
+test("Turn helpers preserve abort-history prompt context when queued turns are edited", () => {
+  const turn = {
+    kind: "prompt" as const,
+    chatId: 99,
+    replyToMessageId: 10,
+    sourceMessageIds: [10],
+    queueOrder: 1,
+    queueLane: "default" as const,
+    laneOrder: 1,
+    queuedAttachments: [],
+    content: [
+      {
+        type: "text" as const,
+        text:
+          "[telegram]\n\n" +
+          "Earlier Telegram messages arrived after an aborted turn. " +
+          "Treat them as prior user messages, in order:\n\n" +
+          "1. older Current Telegram message: quote\n\n" +
+          "Current Telegram message:\nold current",
+      },
+    ],
+    historyText: "old current",
+    statusSummary: "old current",
+  };
+  const updated = updateTelegramPromptTurnText({
+    turn,
+    telegramPrefix: "[telegram]",
+    rawText: "new current",
+  });
+  assert.equal(
+    (updated.content[0] as { type: "text"; text: string }).text,
+    "[telegram]\n\n" +
+      "Earlier Telegram messages arrived after an aborted turn. " +
+      "Treat them as prior user messages, in order:\n\n" +
+      "1. older Current Telegram message: quote\n\n" +
+      "Current Telegram message:\nnew current",
+  );
+  assert.equal(updated.historyText, "new current");
+  assert.equal(updated.statusSummary, "new current");
+});
+
 test("Turn helpers assemble prompt turns with text, ids, history, and image payloads", async () => {
   const turn = await buildTelegramPromptTurn({
     telegramPrefix: "[telegram]",

package/tests/updates.test.ts

@@ -15,6 +15,7 @@ import {
   executeTelegramUpdatePlan,
   extractDeletedTelegramMessageIds,
   getAuthorizedTelegramCallbackQuery,
+  getAuthorizedTelegramEditedMessage,
   getAuthorizedTelegramMessage,
   getTelegramAuthorizationState,
   normalizeTelegramReactionEmoji,
@@ -74,7 +75,7 @@ test("Update routing extracts only private human callback queries", () => {
   assert.ok(query);
 });
 
-test("Update routing extracts private human messages from message or edited_message", () => {
+test("Update routing extracts private human messages and edited messages separately", () => {
   assert.equal(
     getAuthorizedTelegramMessage({
       message: {
@@ -85,12 +86,19 @@ test("Update routing extracts private human messages from message or edited_mess
     undefined,
   );
   const directMessage = getAuthorizedTelegramMessage({
-    edited_message: {
+    message: {
       chat: { type: "private" },
       from: { id: 1, is_bot: false },
     },
   });
   assert.ok(directMessage);
+  const editedMessage = getAuthorizedTelegramEditedMessage({
+    edited_message: {
+      chat: { type: "private" },
+      from: { id: 1, is_bot: false },
+    },
+  });
+  assert.ok(editedMessage);
 });
 
 test("Update flow prioritizes deleted business-message handling over other update kinds", () => {
@@ -107,7 +115,7 @@ test("Update flow prioritizes deleted business-message handling over other updat
   assert.deepEqual(action, { kind: "deleted", messageIds: [1, 2] });
 });
 
-test("Update flow returns authorized callback and message actions", () => {
+test("Update flow returns authorized callback, message, and edit actions", () => {
   const callbackAction = buildTelegramUpdateFlowAction(
     {
       callback_query: {
@@ -119,7 +127,9 @@ test("Update flow returns authorized callback and message actions", () => {
   );
   assert.equal(callbackAction.kind, "callback");
   assert.deepEqual(
-    callbackAction.kind === "callback" ? callbackAction.authorization : undefined,
+    callbackAction.kind === "callback"
+      ? callbackAction.authorization
+      : undefined,
     { kind: "allow" },
   );
   const messageAction = buildTelegramUpdateFlowAction({
@@ -133,6 +143,16 @@ test("Update flow returns authorized callback and message actions", () => {
     messageAction.kind === "message" ? messageAction.authorization : undefined,
     { kind: "pair", userId: 9 },
   );
+  const editAction = buildTelegramUpdateFlowAction(
+    {
+      edited_message: {
+        chat: { type: "private" },
+        from: { id: 9, is_bot: false },
+      },
+    },
+    9,
+  );
+  assert.equal(editAction.kind, "edited-message");
 });
 
 test("Update flow ignores unauthorized transport shapes and preserves reaction events", () => {
@@ -223,10 +243,10 @@ test("Update runtime executes delete and reaction plans through the right side e
     {
       ctx: {} as never,
       removePendingMediaGroupMessages: (ids) => {
-        events.push(`media:${ids.join(',')}`);
+        events.push(`media:${ids.join(",")}`);
       },
       removeQueuedTelegramTurnsByMessageIds: (ids) => {
-        events.push(`queue:${ids.join(',')}`);
+        events.push(`queue:${ids.join(",")}`);
         return ids.length;
       },
       handleAuthorizedTelegramReactionUpdate: async () => {
@@ -237,6 +257,7 @@ test("Update runtime executes delete and reaction plans through the right side e
       handleAuthorizedTelegramCallbackQuery: async () => {},
       sendTextReply: async () => undefined,
       handleAuthorizedTelegramMessage: async () => {},
+      handleAuthorizedTelegramEditedMessage: async () => {},
     },
   );
   assert.deepEqual(events, ["media:1,2", "queue:1,2"]);
@@ -271,9 +292,47 @@ test("Update runtime can execute directly from raw updates", async () => {
       handleAuthorizedTelegramMessage: async () => {
         events.push("message");
       },
+      handleAuthorizedTelegramEditedMessage: async () => {
+        events.push("edited-message");
+      },
+    },
+  );
+  assert.deepEqual(events, [
+    "pair",
+    "reply:Telegram bridge paired with this account.",
+    "message",
+  ]);
+});
+
+test("Update runtime routes edited messages without creating normal message turns", async () => {
+  const events: string[] = [];
+  await executeTelegramUpdate(
+    {
+      edited_message: {
+        chat: { id: 10, type: "private" },
+        message_id: 20,
+        from: { id: 7, is_bot: false },
+      },
+    },
+    7,
+    {
+      ctx: {} as never,
+      removePendingMediaGroupMessages: () => {},
+      removeQueuedTelegramTurnsByMessageIds: () => 0,
+      handleAuthorizedTelegramReactionUpdate: async () => {},
+      pairTelegramUserIfNeeded: async () => false,
+      answerCallbackQuery: async () => {},
+      handleAuthorizedTelegramCallbackQuery: async () => {},
+      sendTextReply: async () => undefined,
+      handleAuthorizedTelegramMessage: async () => {
+        events.push("message");
+      },
+      handleAuthorizedTelegramEditedMessage: async () => {
+        events.push("edited-message");
+      },
     },
   );
-  assert.deepEqual(events, ["pair", "reply:Telegram bridge paired with this account.", "message"]);
+  assert.deepEqual(events, ["edited-message"]);
 });
 
 test("Update runtime handles callback deny and message pair flows", async () => {
@@ -311,6 +370,9 @@ test("Update runtime handles callback deny and message pair flows", async () =>
       handleAuthorizedTelegramMessage: async () => {
         events.push("message");
       },
+      handleAuthorizedTelegramEditedMessage: async () => {
+        events.push("edited-message");
+      },
     },
   );
   await executeTelegramUpdatePlan(
@@ -340,6 +402,9 @@ test("Update runtime handles callback deny and message pair flows", async () =>
       handleAuthorizedTelegramMessage: async () => {
         events.push("message");
       },
+      handleAuthorizedTelegramEditedMessage: async () => {
+        events.push("edited-message");
+      },
     },
   );
   assert.deepEqual(events, [