@llblab/pi-telegram 0.16.6 → 0.17.0

package/lib/rendering.ts

@@ -1,7 +1,7 @@
 /**
- * Telegram preview and markdown rendering helpers
+ * Telegram UI/compat rendering helpers
  * Zones: telegram rendering, shared text utils
- * Converts assistant output into Telegram-safe plain text and HTML chunks with chunk-boundary handling
+ * Converts bridge-owned UI/status/menu/interactive text into Telegram-safe plain text and HTML chunks with chunk-boundary handling
  */
 
 export const MAX_MESSAGE_LENGTH = 4096;
@@ -488,353 +488,7 @@ function splitLeadingMarkdownBlankLines(markdown: string): {
   };
 }
 
-export type TelegramPreviewRenderStrategy = "plain" | "rich-stable-blocks";
-
-export interface TelegramPreviewSnapshotState {
-  pendingText: string;
-  lastSentText: string;
-  lastSentParseMode?: "HTML";
-  lastSentStrategy?: TelegramPreviewRenderStrategy;
-}
-
-export interface TelegramPreviewSnapshot extends TelegramRenderedChunk {
-  sourceText: string;
-  strategy: TelegramPreviewRenderStrategy;
-}
-
-export function buildTelegramPreviewFlushText(options: {
-  state: TelegramPreviewSnapshotState;
-  maxMessageLength: number;
-  renderPreviewText: (markdown: string) => string;
-}): string | undefined {
-  const rawText = options.state.pendingText.trim();
-  const previewText = options.renderPreviewText(rawText).trim();
-  if (!previewText || previewText === options.state.lastSentText) {
-    return undefined;
-  }
-  return previewText.length > options.maxMessageLength
-    ? previewText.slice(0, options.maxMessageLength)
-    : previewText;
-}
-
-function buildTelegramPlainPreviewSnapshot(options: {
-  sourceText: string;
-  state: TelegramPreviewSnapshotState;
-  maxMessageLength: number;
-  renderPreviewText: (markdown: string) => string;
-}): TelegramPreviewSnapshot | undefined {
-  const previewText = options.renderPreviewText(options.sourceText).trim();
-  if (!previewText) return undefined;
-  const truncatedPreviewText =
-    previewText.length > options.maxMessageLength
-      ? previewText.slice(0, options.maxMessageLength)
-      : previewText;
-  if (
-    truncatedPreviewText === options.state.lastSentText &&
-    options.state.lastSentStrategy === "plain"
-  ) {
-    return undefined;
-  }
-  return {
-    text: truncatedPreviewText,
-    sourceText: options.sourceText,
-    strategy: "plain",
-  };
-}
-
-interface TelegramStablePreviewSplit {
-  stableMarkdown: string;
-  unstableTail: string;
-}
-
-function buildTelegramStablePreviewSplit(
-  lines: string[],
-  stableEndIndex: number,
-): TelegramStablePreviewSplit {
-  return {
-    stableMarkdown: lines.slice(0, stableEndIndex).join("\n"),
-    unstableTail: lines.slice(stableEndIndex).join("\n"),
-  };
-}
-
-function collectTelegramStablePreviewTextBlockLines(
-  lines: string[],
-  index: number,
-): { nextIndex: number } {
-  let nextIndex = index;
-  while (nextIndex < lines.length) {
-    const current = lines[nextIndex] ?? "";
-    const following = lines[nextIndex + 1] ?? "";
-    if (current.trim().length === 0) break;
-    if (
-      nextIndex !== index &&
-      (isFencedCodeStart(current) ||
-        canStartIndentedCodeBlock(lines, nextIndex) ||
-        /^\s*>/.test(current) ||
-        (current.includes("|") && isMarkdownTableSeparator(following)))
-    ) {
-      break;
-    }
-    nextIndex += 1;
-  }
-  return { nextIndex };
-}
-
-function splitTelegramStablePreviewMarkdown(
-  markdown: string,
-): TelegramStablePreviewSplit {
-  const normalized = normalizeMarkdownDocument(markdown);
-  if (normalized.length === 0) return { stableMarkdown: "", unstableTail: "" };
-  const lines = normalized.split("\n");
-  let index = 0;
-  let stableEndIndex = 0;
-  while (index < lines.length) {
-    while (index < lines.length && (lines[index] ?? "").trim().length === 0) {
-      index += 1;
-    }
-    if (index >= lines.length) break;
-    const blockStart = index;
-    const line = lines[index] ?? "";
-    const nextLine = lines[index + 1] ?? "";
-    const fence = parseMarkdownFence(line);
-    if (fence) {
-      const block = collectFencedMarkdownCodeLines(lines, index, fence);
-      if (!block.closed) {
-        return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-      }
-      index = block.nextIndex;
-      stableEndIndex = index;
-      continue;
-    }
-    if (line.includes("|") && isMarkdownTableSeparator(nextLine)) {
-      const block = collectMarkdownTableBlockLines(lines, index);
-      index = block.nextIndex;
-      if (index >= lines.length) {
-        return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-      }
-      stableEndIndex = index;
-      continue;
-    }
-    if (canStartIndentedCodeBlock(lines, index)) {
-      const block = collectIndentedMarkdownCodeLines(lines, index);
-      index = block.nextIndex;
-      if (index >= lines.length) {
-        return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-      }
-      stableEndIndex = index;
-      continue;
-    }
-    if (/^\s*>/.test(line)) {
-      const block = collectMarkdownQuoteBlockLines(lines, index);
-      index = block.nextIndex;
-      if (index >= lines.length) {
-        return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-      }
-      stableEndIndex = index;
-      continue;
-    }
-    const block = collectTelegramStablePreviewTextBlockLines(lines, blockStart);
-    index = block.nextIndex;
-    if (index >= lines.length) {
-      return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-    }
-    stableEndIndex = index;
-  }
-  return buildTelegramStablePreviewSplit(lines, stableEndIndex);
-}
-
-function renderTelegramStablePreviewChunk(options: {
-  stableMarkdown: string;
-  maxMessageLength: number;
-  renderTelegramMessage: (
-    text: string,
-    options?: { mode?: TelegramRenderMode },
-  ) => TelegramRenderedChunk[];
-}): TelegramRenderedChunk | undefined {
-  const stableChunk = options.renderTelegramMessage(options.stableMarkdown, {
-    mode: "markdown",
-  })[0];
-  if (!stableChunk || stableChunk.text.length === 0) return undefined;
-  if (stableChunk.text.length > options.maxMessageLength) return undefined;
-  return stableChunk;
-}
-
-function appendTelegramUnstablePreviewTail(options: {
-  previewText: string;
-  stableMarkdown: string;
-  unstableTail: string;
-  maxMessageLength: number;
-}): string {
-  if (options.unstableTail.length === 0) return options.previewText;
-  const tail = splitLeadingMarkdownBlankLines(options.unstableTail);
-  const minimumBlankLinesBeforeTail = endsWithMarkdownHeadingLine(
-    options.stableMarkdown,
-  )
-    ? 1
-    : 0;
-  const blankLinesBeforeTail = Math.max(
-    tail.blankLines,
-    minimumBlankLinesBeforeTail,
-  );
-  const separator =
-    tail.remainingText.length > 0 ? "\n".repeat(blankLinesBeforeTail + 1) : "";
-  const tailText = escapeHtml(tail.remainingText);
-  const candidate = `${options.previewText}${separator}${tailText}`;
-  return candidate.length <= options.maxMessageLength
-    ? candidate
-    : options.previewText;
-}
-
-function isTelegramPreviewSnapshotUnchanged(options: {
-  text: string;
-  parseMode?: "HTML";
-  state: TelegramPreviewSnapshotState;
-  strategy: TelegramPreviewRenderStrategy;
-}): boolean {
-  return (
-    options.text === options.state.lastSentText &&
-    options.parseMode === options.state.lastSentParseMode &&
-    options.strategy === options.state.lastSentStrategy
-  );
-}
-
-export function buildTelegramPreviewSnapshot(options: {
-  state: TelegramPreviewSnapshotState;
-  maxMessageLength: number;
-  renderPreviewText: (markdown: string) => string;
-  renderTelegramMessage: (
-    text: string,
-    options?: { mode?: TelegramRenderMode },
-  ) => TelegramRenderedChunk[];
-}): TelegramPreviewSnapshot | undefined {
-  const sourceText = options.state.pendingText.trim();
-  if (!sourceText) return undefined;
-  const split = splitTelegramStablePreviewMarkdown(sourceText);
-  if (split.stableMarkdown.length === 0) {
-    return buildTelegramPlainPreviewSnapshot({
-      sourceText,
-      state: options.state,
-      maxMessageLength: options.maxMessageLength,
-      renderPreviewText: options.renderPreviewText,
-    });
-  }
-  const stableChunk = renderTelegramStablePreviewChunk({
-    stableMarkdown: split.stableMarkdown,
-    maxMessageLength: options.maxMessageLength,
-    renderTelegramMessage: options.renderTelegramMessage,
-  });
-  if (!stableChunk) {
-    return buildTelegramPlainPreviewSnapshot({
-      sourceText,
-      state: options.state,
-      maxMessageLength: options.maxMessageLength,
-      renderPreviewText: options.renderPreviewText,
-    });
-  }
-  const previewText = appendTelegramUnstablePreviewTail({
-    previewText: stableChunk.text,
-    stableMarkdown: split.stableMarkdown,
-    unstableTail: split.unstableTail,
-    maxMessageLength: options.maxMessageLength,
-  });
-  if (
-    isTelegramPreviewSnapshotUnchanged({
-      text: previewText,
-      parseMode: stableChunk.parseMode,
-      state: options.state,
-      strategy: "rich-stable-blocks",
-    })
-  ) {
-    return undefined;
-  }
-  return {
-    text: previewText,
-    parseMode: stableChunk.parseMode,
-    sourceText,
-    strategy: "rich-stable-blocks",
-  };
-}
-
-export function renderMarkdownPreviewText(markdown: string): string {
-  const normalized = normalizeMarkdownDocument(markdown);
-  if (normalized.length === 0) return "";
-  const output: string[] = [];
-  const lines = normalized.split("\n");
-  let activeFence: { marker: "`" | "~"; length: number } | undefined;
-  for (const rawLine of lines) {
-    const line = rawLine ?? "";
-    const fence = parseMarkdownFence(line);
-    if (activeFence) {
-      if (fence && isMatchingMarkdownFence(line, activeFence)) {
-        activeFence = undefined;
-        continue;
-      }
-      if (line.trim().length === 0) {
-        output.push("");
-        continue;
-      }
-      output.push(line);
-      continue;
-    }
-    if (fence) {
-      activeFence = { marker: fence.marker, length: fence.length };
-      continue;
-    }
-    if (line.trim().length === 0) {
-      output.push("");
-      continue;
-    }
-    if (isMarkdownTableSeparator(line)) {
-      continue;
-    }
-    const heading = matchMarkdownHeadingLine(line);
-    if (heading) {
-      output.push(stripInlineMarkdownToPlainText(heading[2] ?? ""));
-      continue;
-    }
-    const task = line.match(/^(\s*)([-*+]|\d+\.)\s+\[([ xX])\]\s+(.+)$/);
-    if (task) {
-      const indent = " ".repeat((task[1] ?? "").length);
-      const listMarker = task[2] ?? "-";
-      const checkboxMarker =
-        (task[3] ?? " ").toLowerCase() === "x" ? "[x]" : "[ ]";
-      const taskPrefix = isMarkdownNumberedListMarker(listMarker)
-        ? `${listMarker} ${checkboxMarker}`
-        : checkboxMarker;
-      output.push(
-        `${indent}${taskPrefix} ${stripInlineMarkdownToPlainText(task[4] ?? "")}`,
-      );
-      continue;
-    }
-    const bullet = line.match(/^(\s*)[-*+]\s+(.+)$/);
-    if (bullet) {
-      output.push(
-        `${" ".repeat((bullet[1] ?? "").length)}- ${stripInlineMarkdownToPlainText(bullet[2] ?? "")}`,
-      );
-      continue;
-    }
-    const numbered = line.match(/^(\s*\d+\.)\s+(.+)$/);
-    if (numbered) {
-      output.push(
-        `${numbered[1]} ${stripInlineMarkdownToPlainText(numbered[2] ?? "")}`,
-      );
-      continue;
-    }
-    const quote = line.match(/^\s*>\s?(.+)$/);
-    if (quote) {
-      output.push(`> ${stripInlineMarkdownToPlainText(quote[1] ?? "")}`);
-      continue;
-    }
-    if (/^\s*([-*_]\s*){3,}\s*$/.test(line)) {
-      output.push("────────");
-      continue;
-    }
-    output.push(stripInlineMarkdownToPlainText(line));
-  }
-  return output.join("\n");
-}
-
-// --- Rich Markdown Rendering ---
+// --- UI Markdown-to-Telegram-HTML Rendering ---
 
 function renderDelimitedInlineStyle(
   text: string,

package/lib/replies.ts

@@ -1,12 +1,14 @@
 /**
  * Telegram reply delivery helpers
- * Zones: telegram outbound, rendering transport
- * Owns rendered-message delivery, reply transport wiring, and plain or markdown final replies
+ * Zones: telegram outbound, native rich markdown, UI/compat rendering transport
+ * Owns native assistant replies, rendered UI delivery, reply transport wiring, and plain text replies
  */
 
 import { assertTelegramInlineKeyboardCallbackData } from "./keyboard.ts";
 import type {
+  TelegramInputRichMessage,
   TelegramReplyParameters,
+  TelegramSendRichMessageBody,
   TelegramSentMessage,
 } from "./telegram-api.ts";
 import {
@@ -21,6 +23,9 @@ export {
   type TelegramRenderMode,
 };
 
+export const TELEGRAM_RICH_MESSAGE_MAX_CHARS = 32768;
+export const TELEGRAM_RICH_MESSAGE_MAX_BLOCKS = 500;
+
 // --- Reply Dedup ---
 
 /** Non-persistent reply deduplication for a single agent turn.
@@ -138,7 +143,8 @@ export interface TelegramReplyDeliveryDeps<TReplyMarkup> {
   editMessage: (body: {
     chat_id: number;
     message_id: number;
-    text: string;
+    text?: string;
+    rich_message?: TelegramInputRichMessage;
     parse_mode?: "HTML";
     reply_markup?: TReplyMarkup;
   }) => Promise<unknown>;
@@ -251,24 +257,180 @@ export async function sendTelegramPlainReply(
   return deps.sendRenderedChunks(chunks);
 }
 
-export async function sendTelegramMarkdownReply<TReplyMarkup = unknown>(
+export function splitTelegramNativeMarkdown(markdown: string): string[] {
+  if (
+    markdown.length <= TELEGRAM_RICH_MESSAGE_MAX_CHARS &&
+    countTelegramNativeMarkdownBlocks(markdown) <= TELEGRAM_RICH_MESSAGE_MAX_BLOCKS
+  ) {
+    return [markdown];
+  }
+  const chunks: string[] = [];
+  let current = "";
+  let currentBlockCount = 0;
+  for (const rawBlock of splitTelegramNativeMarkdownBlocks(markdown)) {
+    for (const block of splitTelegramNativeMarkdownCountedBlocks(rawBlock)) {
+      const blockCount = countTelegramNativeMarkdownBlocks(block);
+      const candidate = current ? `${current}\n\n${block}` : block;
+      const exceedsChars = candidate.length > TELEGRAM_RICH_MESSAGE_MAX_CHARS;
+      const exceedsBlocks = currentBlockCount + blockCount > TELEGRAM_RICH_MESSAGE_MAX_BLOCKS;
+      if (!exceedsChars && !exceedsBlocks) {
+        current = candidate;
+        currentBlockCount += blockCount;
+        continue;
+      }
+      if (current) chunks.push(current.trimEnd());
+      if (
+        block.length <= TELEGRAM_RICH_MESSAGE_MAX_CHARS &&
+        blockCount <= TELEGRAM_RICH_MESSAGE_MAX_BLOCKS
+      ) {
+        current = block;
+        currentBlockCount = blockCount;
+        continue;
+      }
+      chunks.push(...splitTelegramNativeMarkdownLongBlock(block));
+      current = "";
+      currentBlockCount = 0;
+    }
+  }
+  if (current) chunks.push(current.trimEnd());
+  return chunks;
+}
+
+function splitTelegramNativeMarkdownBlocks(markdown: string): string[] {
+  const blocks: string[] = [];
+  const current: string[] = [];
+  let fence: { marker: "`" | "~"; length: number } | undefined;
+  const flush = (): void => {
+    if (current.length === 0) return;
+    blocks.push(current.join("\n"));
+    current.length = 0;
+  };
+  for (const line of markdown.split("\n")) {
+    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (!fence && line.trim().length === 0) {
+      flush();
+      continue;
+    }
+    current.push(line);
+    if (!fence && fenceMatch) {
+      const markerText = fenceMatch[1] ?? "```";
+      fence = { marker: markerText[0] as "`" | "~", length: markerText.length };
+      continue;
+    }
+    if (
+      fence &&
+      new RegExp(`^ {0,3}${fence.marker}{${fence.length},}\\s*$`).test(line)
+    ) {
+      fence = undefined;
+    }
+  }
+  flush();
+  return blocks;
+}
+
+function splitTelegramNativeMarkdownCountedBlocks(block: string): string[] {
+  if (countTelegramNativeMarkdownBlocks(block) <= TELEGRAM_RICH_MESSAGE_MAX_BLOCKS) {
+    return [block];
+  }
+  const chunks: string[] = [];
+  let current: string[] = [];
+  let fence: { marker: "`" | "~"; length: number } | undefined;
+  for (const line of block.split("\n")) {
+    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (!fence && current.length >= TELEGRAM_RICH_MESSAGE_MAX_BLOCKS) {
+      chunks.push(current.join("\n"));
+      current = [];
+    }
+    current.push(line);
+    if (!fence && fenceMatch) {
+      const markerText = fenceMatch[1] ?? "```";
+      fence = { marker: markerText[0] as "`" | "~", length: markerText.length };
+      continue;
+    }
+    if (
+      fence &&
+      new RegExp(`^ {0,3}${fence.marker}{${fence.length},}\\s*$`).test(line)
+    ) {
+      fence = undefined;
+    }
+  }
+  if (current.length > 0) chunks.push(current.join("\n"));
+  return chunks;
+}
+
+function countTelegramNativeMarkdownBlocks(block: string): number {
+  if (/^ {0,3}(`{3,}|~{3,})/.test(block)) return 1;
+  const lines = block.split("\n").filter((line) => line.trim().length > 0);
+  if (lines.some((line) => /^\s*([-*+] |\d+\. |>|\|)/.test(line))) {
+    return Math.max(1, lines.length);
+  }
+  return 1;
+}
+
+function splitTelegramNativeMarkdownLongBlock(block: string): string[] {
+  const chunks: string[] = [];
+  let remaining = block;
+  while (remaining.length > TELEGRAM_RICH_MESSAGE_MAX_CHARS) {
+    const window = remaining.slice(0, TELEGRAM_RICH_MESSAGE_MAX_CHARS + 1);
+    const splitIndex = findTelegramNativeMarkdownSplitIndex(window);
+    chunks.push(remaining.slice(0, splitIndex).trimEnd());
+    remaining = remaining.slice(splitIndex).trimStart();
+  }
+  if (remaining.length > 0) chunks.push(remaining);
+  return chunks;
+}
+
+function findTelegramNativeMarkdownSplitIndex(text: string): number {
+  const hardLimit = TELEGRAM_RICH_MESSAGE_MAX_CHARS;
+  const paragraphIndex = text.lastIndexOf("\n\n", hardLimit);
+  if (paragraphIndex > 0) return paragraphIndex + 2;
+  const lineIndex = text.lastIndexOf("\n", hardLimit);
+  if (lineIndex > 0) return lineIndex + 1;
+  const spaceIndex = text.lastIndexOf(" ", hardLimit);
+  if (spaceIndex > 0) return spaceIndex + 1;
+  return hardLimit;
+}
+
+export async function sendTelegramNativeMarkdownReply<TReplyMarkup = unknown>(
+  chatId: number,
+  replyToMessageId: number | undefined,
   markdown: string,
-  deps: TelegramReplyRuntimeDeps,
+  deps: {
+    sendRichMessage: (
+      body: TelegramSendRichMessageBody,
+    ) => Promise<TelegramSentMessage>;
+  },
   options?: { replyMarkup?: TReplyMarkup },
 ): Promise<number | undefined> {
-  const chunks = deps.renderTelegramMessage(markdown, { mode: "markdown" });
-  if (chunks.length === 0) {
-    return sendTelegramPlainReply(markdown, deps);
+  assertTelegramInlineKeyboardCallbackData(options?.replyMarkup);
+  let lastMessageId: number | undefined;
+  const chunks = splitTelegramNativeMarkdown(markdown);
+  for (const [index, chunk] of chunks.entries()) {
+    const replyParameters =
+      index === 0
+        ? buildTelegramReplyParameters(chatId, replyToMessageId)
+        : undefined;
+    const sent = await deps.sendRichMessage({
+      chat_id: chatId,
+      rich_message: { markdown: chunk, skip_entity_detection: true },
+      reply_markup: index === chunks.length - 1 ? options?.replyMarkup : undefined,
+      ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+    });
+    lastMessageId = sent.message_id;
   }
-  return deps.sendRenderedChunks(chunks, options);
+  return lastMessageId;
 }
 
+// UI/compat regular-message runtime for bridge-owned text and interactive
+// surfaces. Assistant and guest Markdown delivery bypass this path and use
+// native Rich Message helpers above.
 export interface TelegramRenderedMessageRuntimeDeps<TReplyMarkup> {
   renderTelegramMessage: (
     text: string,
     options?: { mode?: TelegramRenderMode },
   ) => TelegramRenderedChunk[];
   replyTransport: TelegramReplyTransport<TReplyMarkup>;
+  sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
 }
 
 export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
@@ -312,6 +474,7 @@ export interface TelegramRenderedMessageDeliveryRuntimeDeps<
     text: string,
     options?: { mode?: TelegramRenderMode },
   ) => TelegramRenderedChunk[];
+  sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
 }
 
 export function createTelegramRenderedMessageDeliveryRuntime<TReplyMarkup>(
@@ -327,6 +490,7 @@ export function createTelegramRenderedMessageDeliveryRuntime<TReplyMarkup>(
       renderTelegramMessage:
         deps.renderTelegramMessage ?? renderTelegramMessage,
       replyTransport,
+      sendRichMessage: deps.sendRichMessage,
     }),
   };
 }
@@ -349,18 +513,11 @@ export function createTelegramRenderedMessageRuntime<TReplyMarkup>(
       );
     },
     sendMarkdownReply: async (chatId, replyToMessageId, markdown, options) => {
-      return sendTelegramMarkdownReply(
+      return sendTelegramNativeMarkdownReply(
+        chatId,
+        replyToMessageId,
         markdown,
-        {
-          renderTelegramMessage: deps.renderTelegramMessage,
-          sendRenderedChunks: (chunks, chunkOptions) =>
-            deps.replyTransport.sendRenderedChunks(chatId, chunks, {
-              replyToMessageId,
-              replyMarkup: chunkOptions?.replyMarkup as
-                | TReplyMarkup
-                | undefined,
-            }),
-        },
+        { sendRichMessage: deps.sendRichMessage },
         options,
       );
     },
@@ -438,23 +595,21 @@ export function dedupSendMarkdownReply<TReplyMarkup = unknown>(
 }
 
 /**
- * Guest reply sender: renders Markdown → HTML, sends via answerGuestQuery.
- * Keeps guest rendering inside the replies domain so the orchestration layer
- * (index.ts) does not import from rendering.ts directly. */
+ * Guest reply sender: answers guest queries with native Rich Markdown content.
+ * Guest queries use InlineQueryResult input_message_content rather than chat
+ * sendRichMessage, so this stays as a dedicated guest transport adapter.
+ */
 export function createGuestMarkdownReplySender(deps: {
-  renderTelegramMessage: (
-    text: string,
-    options?: { mode?: TelegramRenderMode },
-  ) => TelegramRenderedChunk[];
   answerGuestQuery: (
     guestQueryId: string,
     text?: string,
-    options?: { parseMode?: string },
+    options?: { parseMode?: string; richMessage?: TelegramInputRichMessage },
   ) => Promise<void>;
 }) {
   return async (guestQueryId: string, markdown: string) => {
-    const chunks = deps.renderTelegramMessage(markdown, { mode: "markdown" });
-    const html = chunks.length > 0 ? chunks[0].text : markdown;
-    await deps.answerGuestQuery(guestQueryId, html, { parseMode: "HTML" });
+    const [richMarkdown = markdown] = splitTelegramNativeMarkdown(markdown);
+    await deps.answerGuestQuery(guestQueryId, undefined, {
+      richMessage: { markdown: richMarkdown, skip_entity_detection: true },
+    });
   };
 }

package/lib/routing.ts

@@ -93,13 +93,13 @@ export interface TelegramInboundRouteRuntimeDeps<
     chatId: number,
     messageId: number,
     text: string,
-    mode: "html" | "plain",
+    mode: "markdown" | "html" | "plain",
     replyMarkup: Menu.TelegramReplyMarkup,
   ) => Promise<void>;
   sendInteractiveMessage?: (
     chatId: number,
     text: string,
-    mode: "html" | "plain",
+    mode: "markdown" | "html" | "plain",
     replyMarkup: Menu.TelegramReplyMarkup,
   ) => Promise<number | undefined>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;