@llblab/pi-telegram 0.2.0

package/tests/replies.test.ts

@@ -0,0 +1,362 @@
+/**
+ * Regression tests for the Telegram replies domain
+ * Covers preview decisions, rendered-message delivery, and plain or markdown reply sending in one suite
+ */
+
+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({
+    sendMessage: async (body) => {
+      events.push(`send:${body.chat_id}:${body.text}`);
+      return { message_id: 5 };
+    },
+    editMessage: async (body) => {
+      events.push(`edit:${body.chat_id}:${body.message_id}:${body.text}`);
+    },
+  });
+  assert.equal(await transport.sendRenderedChunks(7, [{ text: "one" }]), 5);
+  assert.equal(await transport.editRenderedMessage(7, 9, [{ text: "two" }]), 9);
+  assert.deepEqual(events, ["send:7:one", "edit:7:9:two"]);
+});
+
+test("Reply delivery sends chunks and applies reply markup only to the last chunk", async () => {
+  const sentBodies: Array<Record<string, unknown>> = [];
+  const messageId = await sendTelegramRenderedChunks(
+    7,
+    [{ text: "one" }, { text: "two", parseMode: "HTML" }],
+    {
+      sendMessage: async (body) => {
+        sentBodies.push(body);
+        return { message_id: sentBodies.length };
+      },
+      editMessage: async () => {},
+    },
+    {
+      replyMarkup: {
+        inline_keyboard: [[{ text: "ok", callback_data: "noop" }]],
+      },
+    },
+  );
+  assert.equal(messageId, 2);
+  assert.deepEqual(sentBodies, [
+    { chat_id: 7, text: "one", parse_mode: undefined, reply_markup: undefined },
+    {
+      chat_id: 7,
+      text: "two",
+      parse_mode: "HTML",
+      reply_markup: {
+        inline_keyboard: [[{ text: "ok", callback_data: "noop" }]],
+      },
+    },
+  ]);
+});
+
+test("Reply delivery edits the first chunk and sends remaining chunks separately", async () => {
+  const editedBodies: Array<Record<string, unknown>> = [];
+  const sentBodies: Array<Record<string, unknown>> = [];
+  const result = await editTelegramRenderedMessage(
+    7,
+    99,
+    [{ text: "first", parseMode: "HTML" }, { text: "second" }],
+    {
+      sendMessage: async (body) => {
+        sentBodies.push(body);
+        return { message_id: 123 };
+      },
+      editMessage: async (body) => {
+        editedBodies.push(body);
+      },
+    },
+    {
+      replyMarkup: {
+        inline_keyboard: [[{ text: "ok", callback_data: "noop" }]],
+      },
+    },
+  );
+  assert.equal(result, 123);
+  assert.deepEqual(editedBodies, [
+    {
+      chat_id: 7,
+      message_id: 99,
+      text: "first",
+      parse_mode: "HTML",
+      reply_markup: undefined,
+    },
+  ]);
+  assert.deepEqual(sentBodies, [
+    {
+      chat_id: 7,
+      text: "second",
+      parse_mode: undefined,
+      reply_markup: {
+        inline_keyboard: [[{ text: "ok", callback_data: "noop" }]],
+      },
+    },
+  ]);
+});
+
+test("Reply runtime sends plain replies using the requested parse mode", async () => {
+  const sent: string[] = [];
+  const messageId = await sendTelegramPlainReply(
+    "hello",
+    {
+      renderTelegramMessage: (_text, options) => [
+        { text: options?.mode === "html" ? "html" : "plain" },
+      ],
+      sendRenderedChunks: async (chunks) => {
+        sent.push(chunks[0]?.text ?? "");
+        return 7;
+      },
+    },
+    { parseMode: "HTML" },
+  );
+  assert.equal(messageId, 7);
+  assert.deepEqual(sent, ["html"]);
+});
+
+test("Reply runtime falls back to plain delivery when markdown rendering yields no chunks", async () => {
+  const calls: Array<string> = [];
+  const messageId = await sendTelegramMarkdownReply("hello", {
+    renderTelegramMessage: (_text, options) => {
+      if (options?.mode === "markdown") return [];
+      return [{ text: options?.mode ?? "plain" }];
+    },
+    sendRenderedChunks: async (chunks) => {
+      calls.push(chunks[0]?.text ?? "");
+      return 9;
+    },
+  });
+  assert.equal(messageId, 9);
+  assert.deepEqual(calls, ["plain"]);
+});

package/tests/turns.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Regression tests for the Telegram turn-building domain
+ * Covers queue-summary formatting, prompt construction, and prompt-turn assembly from messages and downloaded files
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  buildTelegramPromptTurn,
+  buildTelegramTurnPrompt,
+  formatTelegramTurnStatusSummary,
+  truncateTelegramQueueSummary,
+} from "../lib/turns.ts";
+
+test("Turn helpers truncate queue summaries predictably", () => {
+  assert.equal(
+    truncateTelegramQueueSummary("one two three four"),
+    "one two three four",
+  );
+  assert.equal(
+    truncateTelegramQueueSummary("one two three four five six"),
+    "one two three four five…",
+  );
+  assert.equal(truncateTelegramQueueSummary("   "), "");
+});
+
+test("Turn helpers build prompt text with history and attachments", () => {
+  const prompt = buildTelegramTurnPrompt({
+    telegramPrefix: "[telegram]",
+    rawText: "current message",
+    files: [{ path: "/tmp/demo.png", fileName: "demo.png", isImage: true }],
+    historyTurns: [{ historyText: "older message" }],
+  });
+  assert.match(prompt, /^\[telegram\]/);
+  assert.match(
+    prompt,
+    /Earlier Telegram messages arrived after an aborted turn/,
+  );
+  assert.match(prompt, /1\. older message/);
+  assert.match(prompt, /Current Telegram message:\ncurrent message/);
+  assert.match(
+    prompt,
+    /Telegram attachments were saved locally:\n- \/tmp\/demo.png/,
+  );
+});
+
+test("Turn helpers summarize text and attachment-only turns", () => {
+  assert.equal(
+    formatTelegramTurnStatusSummary("hello there from telegram", []),
+    "hello there from telegram",
+  );
+  assert.equal(
+    formatTelegramTurnStatusSummary("", [
+      {
+        path: "/tmp/report-final-version.txt",
+        fileName: "report-final-version.txt",
+        isImage: false,
+      },
+    ]),
+    "📎 report-final-version.txt",
+  );
+  assert.equal(
+    formatTelegramTurnStatusSummary("", [
+      { path: "/tmp/a.txt", fileName: "a.txt", isImage: false },
+      { path: "/tmp/b.txt", fileName: "b.txt", isImage: false },
+    ]),
+    "📎 2 attachments",
+  );
+});
+
+test("Turn helpers assemble prompt turns with text, ids, history, and image payloads", async () => {
+  const turn = await buildTelegramPromptTurn({
+    telegramPrefix: "[telegram]",
+    messages: [
+      { message_id: 10, chat: { id: 99 } },
+      { message_id: 11, chat: { id: 99 } },
+    ],
+    historyTurns: [
+      {
+        kind: "prompt",
+        chatId: 99,
+        replyToMessageId: 1,
+        sourceMessageIds: [1],
+        queueOrder: 1,
+        queueLane: "default",
+        laneOrder: 1,
+        queuedAttachments: [],
+        content: [{ type: "text", text: "ignored" }],
+        historyText: "older message",
+        statusSummary: "older",
+      },
+    ],
+    queueOrder: 7,
+    rawText: "current message",
+    files: [
+      {
+        path: "/tmp/demo.png",
+        fileName: "demo.png",
+        isImage: true,
+        mimeType: "image/png",
+      },
+      {
+        path: "/tmp/report.txt",
+        fileName: "report.txt",
+        isImage: false,
+      },
+    ],
+    readBinaryFile: async () => new Uint8Array([1, 2, 3]),
+    inferImageMimeType: () => undefined,
+  });
+  assert.equal(turn.chatId, 99);
+  assert.equal(turn.replyToMessageId, 10);
+  assert.deepEqual(turn.sourceMessageIds, [10, 11]);
+  assert.equal(turn.queueOrder, 7);
+  assert.equal(turn.statusSummary, "current message");
+  assert.equal(
+    turn.historyText,
+    "current message\nAttachments:\n- /tmp/demo.png\n- /tmp/report.txt",
+  );
+  assert.equal(turn.content.length, 2);
+  assert.equal(turn.content[0]?.type, "text");
+  assert.match(
+    (turn.content[0] as { type: "text"; text: string }).text,
+    /Earlier Telegram messages arrived after an aborted turn/,
+  );
+  assert.deepEqual(turn.content[1], {
+    type: "image",
+    data: Buffer.from([1, 2, 3]).toString("base64"),
+    mimeType: "image/png",
+  });
+});