fix(bot): avoid MarkdownV2 parse errors on escaped chunk boundaries

Author: grinev

src/bot/utils/send-with-markdown-fallback.ts

@@ -31,6 +31,26 @@ const MARKDOWN_PARSE_ERROR_MARKERS = [
   "bad request: can't parse",
 ];
 
+function stripMarkdownFormattingOptions<
+  T extends TelegramSendMessageOptions | TelegramEditMessageOptions | undefined,
+>(options: T): T {
+  if (!options) {
+    return options;
+  }
+
+  const rawOptions = {
+    ...options,
+  } as NonNullable<T> & {
+    parse_mode?: unknown;
+    entities?: unknown;
+  };
+
+  delete rawOptions.parse_mode;
+  delete rawOptions.entities;
+
+  return rawOptions as T;
+}
+
 function getErrorText(error: unknown): string {
   const parts: string[] = [];
 
@@ -96,7 +116,7 @@ export async function sendMessageWithMarkdownFallback({
     }
 
     logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
-    return api.sendMessage(chatId, text, options);
+    return api.sendMessage(chatId, text, stripMarkdownFormattingOptions(options));
   }
 }
 
@@ -127,6 +147,6 @@ export async function editMessageWithMarkdownFallback({
     }
 
     logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
-    return api.editMessageText(chatId, messageId, text, options);
+    return api.editMessageText(chatId, messageId, text, stripMarkdownFormattingOptions(options));
   }
 }

src/summary/formatter.ts

@@ -10,21 +10,63 @@ import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
 
-function splitText(text: string, maxLength: number): string[] {
-  const parts: string[] = [];
-  let currentIndex = 0;
+interface SplitTextOptions {
+  avoidTrailingMarkdownEscape?: boolean;
+}
 
-  while (currentIndex < text.length) {
-    let endIndex = currentIndex + maxLength;
+function endsWithOddTrailingBackslashes(text: string, start: number, end: number): boolean {
+  let backslashCount = 0;
 
-    if (endIndex >= text.length) {
-      parts.push(text.slice(currentIndex));
+  for (let index = end - 1; index >= start; index--) {
+    if (text[index] !== "\\") {
       break;
     }
+    backslashCount += 1;
+  }
+
+  return backslashCount % 2 === 1;
+}
+
+function resolveSplitEndIndex(
+  text: string,
+  currentIndex: number,
+  maxLength: number,
+  options?: SplitTextOptions,
+): number {
+  const hardLimit = Math.min(text.length, currentIndex + maxLength);
+  if (hardLimit >= text.length) {
+    return text.length;
+  }
+
+  let endIndex = hardLimit;
+  const breakPoint = text.lastIndexOf("\n", endIndex);
+  if (breakPoint > currentIndex) {
+    endIndex = breakPoint + 1;
+  }
 
-    const breakPoint = text.lastIndexOf("\n", endIndex);
-    if (breakPoint > currentIndex) {
-      endIndex = breakPoint + 1;
+  if (!options?.avoidTrailingMarkdownEscape) {
+    return endIndex;
+  }
+
+  while (endIndex > currentIndex && endsWithOddTrailingBackslashes(text, currentIndex, endIndex)) {
+    endIndex -= 1;
+  }
+
+  return endIndex > currentIndex ? endIndex : hardLimit;
+}
+
+function splitText(text: string, maxLength: number, options?: SplitTextOptions): string[] {
+  const parts: string[] = [];
+  let currentIndex = 0;
+
+  while (currentIndex < text.length) {
+    const endIndex = resolveSplitEndIndex(text, currentIndex, maxLength, options);
+
+    if (endIndex <= currentIndex) {
+      const fallbackEnd = Math.min(text.length, currentIndex + 1);
+      parts.push(text.slice(currentIndex, fallbackEnd));
+      currentIndex = fallbackEnd;
+      continue;
     }
 
     parts.push(text.slice(currentIndex, endIndex));
@@ -252,7 +294,9 @@ export function formatSummaryWithMode(
 
     if (mode === "markdown") {
       const converted = formatMarkdownForTelegram(trimmed);
-      const convertedParts = splitText(converted, normalizedMaxLength);
+      const convertedParts = splitText(converted, normalizedMaxLength, {
+        avoidTrailingMarkdownEscape: true,
+      });
 
       for (const convertedPart of convertedParts) {
         const normalizedPart = convertedPart.trim();

tests/bot/utils/send-with-markdown-fallback.test.ts

@@ -49,6 +49,37 @@ describe("bot/utils/send-with-markdown-fallback", () => {
     });
   });
 
+  it("drops markdown formatting options on send fallback", async () => {
+    const sendMessage = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new Error("Bad Request: can't parse entities: Character '+' is reserved"),
+      )
+      .mockResolvedValueOnce(undefined);
+
+    await sendMessageWithMarkdownFallback({
+      api: { sendMessage },
+      chatId: 777,
+      text: "a+b",
+      options: {
+        reply_markup: { keyboard: [] },
+        parse_mode: "MarkdownV2",
+        entities: [],
+      },
+      parseMode: "MarkdownV2",
+    });
+
+    expect(sendMessage).toHaveBeenCalledTimes(2);
+    expect(sendMessage).toHaveBeenNthCalledWith(1, 777, "a+b", {
+      reply_markup: { keyboard: [] },
+      parse_mode: "MarkdownV2",
+      entities: [],
+    });
+    expect(sendMessage).toHaveBeenNthCalledWith(2, 777, "a+b", {
+      reply_markup: { keyboard: [] },
+    });
+  });
+
   it("does not swallow non-markdown Telegram errors", async () => {
     const sendMessage = vi
       .fn()
@@ -140,4 +171,36 @@ describe("bot/utils/send-with-markdown-fallback", () => {
       reply_markup: { inline_keyboard: [] },
     });
   });
+
+  it("drops markdown formatting options on edit fallback", async () => {
+    const editMessageText = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new Error("Bad Request: can't parse entities: Character '+' is reserved"),
+      )
+      .mockResolvedValueOnce(undefined);
+
+    await editMessageWithMarkdownFallback({
+      api: { editMessageText },
+      chatId: 501,
+      messageId: 902,
+      text: "a+b",
+      options: {
+        reply_markup: { inline_keyboard: [] },
+        parse_mode: "MarkdownV2",
+        entities: [],
+      },
+      parseMode: "MarkdownV2",
+    });
+
+    expect(editMessageText).toHaveBeenCalledTimes(2);
+    expect(editMessageText).toHaveBeenNthCalledWith(1, 501, 902, "a+b", {
+      reply_markup: { inline_keyboard: [] },
+      parse_mode: "MarkdownV2",
+      entities: [],
+    });
+    expect(editMessageText).toHaveBeenNthCalledWith(2, 501, 902, "a+b", {
+      reply_markup: { inline_keyboard: [] },
+    });
+  });
 });

tests/summary/formatter.test.ts

@@ -60,6 +60,13 @@ describe("summary/formatter", () => {
     expect(parts.every((part) => part.length <= 120)).toBe(true);
   });
 
+  it("does not split escaped markdown characters across parts", () => {
+    const parts = formatSummaryWithMode("a+b", "markdown", 2);
+
+    expect(parts).toEqual(["a", "\\+", "b"]);
+    expect(parts.some((part) => part.endsWith("\\"))).toBe(false);
+  });
+
   it("keeps raw code-block parts within the custom limit", () => {
     const parts = formatSummaryWithMode("a".repeat(300), "raw", 120);