@llblab/pi-telegram 0.17.2 → 0.17.4

package/AGENTS.md

@@ -125,7 +125,7 @@ The canonical detailed ownership map lives in [`docs/architecture.md`](./docs/ar
 
 ## 6.4 Entrypoint And Import Boundaries
 
-- Keep the preview domain as a thin streaming lifecycle controller only: draft ids, `sendRichMessageDraft`, voice suppression, serialized flushes, diagnostics, and editable fallback-message state. Do not reintroduce assistant preview rendering there; keep `rendering.ts` scoped to bridge-owned UI/compat regular-message rendering rather than assistant or guest Markdown delivery
+- Keep the preview domain as a thin streaming lifecycle controller only: draft ids, safe-prefix selection for `sendRichMessageDraft`, voice suppression, serialized flushes, diagnostics, and finalization state. Do not reintroduce assistant preview rendering there; keep `rendering.ts` scoped to bridge-owned UI/compat regular-message rendering rather than assistant or guest Markdown delivery. Drafts must only send structurally closed Markdown prefixes; draft failures are not proof that drafts are globally unsupported, so record the failure and skip that preview frame. Do not add raw plain-message fallback previews for assistant Markdown
 - Preview/final delivery ordering is release-critical: finalization must wait for active preview flushes, persisted final delivery should not be followed by a post-final draft-clear call that creates transient draft UI, and regressions should cover in-flight draft flush serialization plus final reply ordering
 - Live Rich Draft observation: `sendMessageDraft(..., undefined)` after a persisted final Rich Message can appear in Telegram clients as a separate animated three-dot draft block before dissolving. Do not use post-final draft-clear for assistant finalization; let the persisted final `sendRichMessage` replace/complete the user-visible lifecycle and reset local preview state only.
 - `RichBlockThinking` / `<tg-thinking>` is draft-only (`sendRichMessageDraft`) and may be useful for a future explicit pre-token preloader, but it is not a persisted final-message primitive and should not be mixed into release-critical finalization behavior without separate UX tests.

package/BACKLOG.md

@@ -1,5 +1,10 @@
 # Project Backlog
 
+- [ ] Track evidence-backed Telegram Rich Markdown normalization follow-ups.
+  - Done when: newly observed Telegram parser-breaking sequences are captured from live/client evidence or minimized fixtures.
+  - Done when: each confirmed sequence has a conservative normalization or safe-degradation rule covered by tests.
+  - Done when: unconfirmed speculative rewrites remain out of the delivery path.
+
 - [ ] Track a public Pi session-replacement hook before adding Telegram `/new`.
   - [ ] Wait for a safe public Pi API.
     - Done when: Pi exposes an API that invokes the same session-replacement path as terminal `/new`.

package/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
-## Unreleased
+## 0.17.4: Native Rich Markdown Splitter Hotfix
+
+- `[Rich Markdown]` Rewrap oversized fenced code, display-math, and fully wrapped inline-formatting blocks when splitting native Rich Markdown at Telegram transport limits. Impact: very long structured Markdown blocks no longer produce invalid partial Rich Markdown chunks, so final assistant replies can stay native without losing long code/math/formatted output.
+- `[Tests]` Added regressions for oversized fenced code, display math, and inline formatting split behavior. Impact: future native splitter changes must preserve structurally valid chunks beyond Telegram's single-message size limit.
+
+## 0.17.3: Native Draft Preview Hotfix
+
+- `[Rich Markdown]` Normalize multiline display-math blocks written as `$$` / content / `$$` into Telegram-supported `math` code fences before native Rich Markdown delivery, while preserving literal delimiters inside code fences. Impact: assistant replies following the Telegram prompt guidance for block formulas no longer risk making the whole Rich Markdown message render as raw Markdown.
+- `[Preview]` Removed assistant plain-message preview fallback paths; failed native draft frames are recorded and skipped because partial Markdown can be temporarily invalid while the final answer remains valid. Draft delivery now sends only structurally closed Markdown prefixes, holding back unclosed inline spans, links, fenced code, comments, and display-math blocks until a safe boundary exists. Impact: assistant previews stay on Telegram's native Rich Draft API and no longer create raw-Markdown fallback bubbles.
+- `[Validation]` Live Telegram smoke-tested native draft/final Rich Markdown delivery with sections, lists, code fences, links, `$$` display math, and inline buttons after reload. Impact: the `0.17.3` hotfix behavior is verified in the target Telegram client path, not only by local tests.
 
 ## 0.17.2: Indented List Rich Markdown Hotfix
 

package/README.md

@@ -134,7 +134,7 @@ The menu is the primary way to inspect and mutate the queue. Reactions are an ex
 
 ### Streaming and native Rich Markdown
 
-Assistant Markdown is sent to Telegram as native Rich Markdown. Streaming previews use Telegram rich-message drafts when available, and final replies persist the same Markdown through `sendRichMessage`. The bridge still strips top-level hidden action comments before delivery and splits only when Telegram transport limits require it.
+Assistant Markdown is sent to Telegram as native Rich Markdown. Streaming previews use Telegram rich-message drafts when a structurally closed Markdown prefix is available, and final replies persist the complete Markdown through `sendRichMessage`. The bridge still strips top-level hidden action comments before delivery and splits only when Telegram transport limits require it.
 
 Telegram HTML rendering remains the default for bridge-owned UI surfaces such as commands, menus, status messages, queue controls, and extension sections, where explicit markup is clearer and easier to maintain. Native Rich Markdown is reserved for model-authored Markdown replies and guest replies that naturally arrive as Markdown.
 

package/docs/architecture.md

@@ -58,7 +58,7 @@ The repository uses a **Flat Domain DAG**:
 - `model` / `menu-model` / `menu-thinking` / `menu-status` / `menu-queue` / `menu-settings` / `menu` / `commands`: model identity, thinking levels, scoped model handling, menu render/callback behavior, slash commands, bot commands, and interactive controls.
 - `sections`: Telegram menu-section registry, opaque section callback tokens, render/callback dispatch, safe section ports, and diagnostics.
 - `keyboard`: shared inline-keyboard reply-markup shape only; feature domains own labels, callback data, and behavior.
-- `preview` / `replies` / `rendering`: throttled native Rich Markdown draft delivery and fallback preview transport, native final reply delivery, reply parameters, transport-limit chunking, and remaining Telegram HTML rendering for bridge-owned UI/compatibility surfaces.
+- `preview` / `replies` / `rendering`: throttled native Rich Markdown draft delivery, native final reply delivery, reply parameters, transport-limit chunking, and remaining Telegram HTML rendering for bridge-owned UI/compatibility surfaces.
 - `outbound-markup`: top-level assistant action comment parsing, attribute parsing, voice reply planning, and preview/delivery stripping.
 - `outbound`: outbound text transformations, voice/button artifact delivery, and generated callback actions.
 - `outbound-attachments`: `telegram_attach`, queued outbound files, stat/limit checks, and photo/document delivery classification.
@@ -191,15 +191,15 @@ During active Telegram-owned turns, assistant message start/update hooks re-arm
 
 ### Rendering And Delivery
 
-Assistant replies use Telegram-native Rich Markdown. Final Markdown is sent directly as `InputRichMessage.markdown` through `sendRichMessage`, streaming previews use `sendRichMessageDraft` when draft delivery is available, and editable fallback previews are finalized through `editMessageText.rich_message`. Guest replies also use native Rich Markdown through `InputRichMessageContent` in `answerGuestQuery` results. The bridge still strips top-level assistant action comments before delivery and may split output only for Telegram transport limits.
+Assistant replies use Telegram-native Rich Markdown. Final Markdown is sent directly as `InputRichMessage.markdown` through `sendRichMessage`, and streaming previews use `sendRichMessageDraft` when draft delivery succeeds. Guest replies also use native Rich Markdown through `InputRichMessageContent` in `answerGuestQuery` results. The bridge still strips top-level assistant action comments before delivery and may split output only for Telegram transport limits.
 
 Assistant delivery guarantees:
 
 - Model-authored Markdown is the source of truth; the bridge does not pre-render assistant Markdown to HTML.
 - Before native Rich Markdown delivery, the bridge normalizes known Bot-API-fragile source forms without changing visible meaning, including space-after-marker blockquotes and dollar-prefixed ticker atoms that Telegram may otherwise treat as unterminated math.
 - Quoted rich replies use Telegram `rich_message` blocks as the prompt-context source when available, so `[reply]` context receives rendered plain text instead of raw `InputRichMessage.markdown` fallback text.
-- Long native Markdown replies are split only at Telegram Rich Message transport limits.
-- Streaming previews pass assistant Markdown through to `sendRichMessageDraft` with ownership checks, voice suppression, serialized flushes, and an editable plain-message fallback when draft delivery is unavailable.
+- Long native Markdown replies are split only at Telegram Rich Message transport limits; oversized fenced code, display-math, and fully wrapped inline-formatting blocks are rewrapped per chunk so persisted Rich Markdown chunks remain structurally valid.
+- Streaming previews pass structurally closed assistant Markdown prefixes through to `sendRichMessageDraft` with ownership checks, voice suppression, and serialized flushes. Unclosed inline spans, links, fenced code, comments, and display-math blocks are held back until a safe boundary exists. Draft failures are recorded and the failing frame is skipped instead of degrading to raw plain-message previews, because partial Markdown can be invalid while the final message remains valid.
 - Preview flushes are serialized so older edits cannot race newer drafts; final delivery waits for active draft flushes and does not perform a post-final draft-clear call.
 
 UI/compat rendering guarantees:

package/docs/public-api.md

@@ -99,7 +99,7 @@ Hidden/default semantics are represented by absence:
 - Voice Reply `hidden`: no `voice.replyMode` key is persisted.
 - Time Injection `hidden`: no `time.injectionMode` key is persisted; if `time` becomes empty, the whole `time` object may be omitted.
 
-Assistant Markdown delivery is native: final replies are sent as `InputRichMessage.markdown` via `sendRichMessage`, draft previews use `sendRichMessageDraft` when available, and fallback preview messages are finalized with `editMessageText.rich_message` when they can be edited in place. Guest replies use `InputRichMessageContent` in `answerGuestQuery` results. Bridge-owned UI surfaces such as menus, status, queue controls, commands, and sections keep explicit Telegram HTML/plain rendering by default because those texts are authored by the bridge or companion extensions for Telegram UI. Companion extension sections may explicitly request `"markdown"`, `"html"`, or `"plain"` per view. There is no `telegram.json` rendering toggle for assistant delivery. The bridge sets `skip_entity_detection: true` for assistant and guest Markdown so technical text such as `/commands`, hashtags, URLs, phone numbers, and card-like numbers does not gain unintended automatic entities; explicit Markdown links still belong in the Markdown source.
+Assistant Markdown delivery is native: final replies are sent as `InputRichMessage.markdown` via `sendRichMessage`, and draft previews use `sendRichMessageDraft` when a structurally closed preview frame is available. Draft-frame failures are recorded and skipped rather than converted into raw plain preview messages, because partial Markdown can be temporarily invalid while the final answer remains valid. Long native replies are split at Telegram Rich Message transport limits, with oversized fenced code, display-math, and fully wrapped inline-formatting blocks rewrapped per chunk so persisted chunks remain structurally valid. Guest replies use `InputRichMessageContent` in `answerGuestQuery` results. Bridge-owned UI surfaces such as menus, status, queue controls, commands, and sections keep explicit Telegram HTML/plain rendering by default because those texts are authored by the bridge or companion extensions for Telegram UI. Companion extension sections may explicitly request `"markdown"`, `"html"`, or `"plain"` per view. There is no `telegram.json` rendering toggle for assistant delivery. The bridge sets `skip_entity_detection: true` for assistant and guest Markdown so technical text such as `/commands`, hashtags, URLs, phone numbers, and card-like numbers does not gain unintended automatic entities; explicit Markdown links still belong in the Markdown source.
 
 Environment variables are stable only where documented in the README: bot-token bootstrap, proxy behavior, agent root, and inbound/outbound file size limits.
 

package/index.ts

@@ -227,12 +227,7 @@ export default function (pi: Pi.ExtensionAPI) {
       sendMessageDraft,
       sendRichMessageDraft,
     }),
-    sendMessage,
-    editMessageText: editTelegramMessageText,
     sendMarkdownReply,
-    editMarkdownMessage: Preview.createTelegramNativeMarkdownMessageEditor({
-      editMessageText: editTelegramMessageText,
-    }),
     recordRuntimeEvent,
     ...replyTransport,
   });

package/lib/preview.ts

@@ -1,35 +1,24 @@
 /**
  * Telegram preview streaming helpers
- * Zones: telegram outbound, native rich markdown drafts, fallback preview transport
- * Owns preview transport selection, runtime updates, and preview finalization
+ * Zones: telegram outbound, native rich markdown drafts
+ * Owns safe draft preview selection, runtime updates, and preview finalization
  */
 
-import type {
-  TelegramEditMessageTextBody,
-  TelegramReplyParameters,
-  TelegramSendMessageBody,
-  TelegramSentMessage,
-} from "./telegram-api.ts";
-import {
-  buildTelegramReplyParameters,
-  normalizeTelegramNativeMarkdown,
-} from "./replies.ts";
+import { normalizeTelegramNativeMarkdown } from "./replies.ts";
 import { stripTelegramCommentMarkupForPreview } from "./outbound.ts";
 import { shouldSuppressPreviewForVoice } from "./voice.ts";
 
 const TELEGRAM_PREVIEW_THROTTLE_MS = 0;
 const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
-const TELEGRAM_FALLBACK_PREVIEW_MESSAGE_MAX_CHARS = 4096;
+const TELEGRAM_DRAFT_PREVIEW_MAX_CHARS = 4096;
 
-export type TelegramDraftSupport = "unknown" | "supported" | "unsupported";
+export type TelegramDraftSupport = "unknown" | "supported";
 
 export interface TelegramPreviewState {
-  mode: "draft" | "message";
+  mode: "draft";
   draftId?: number;
-  messageId?: number;
   pendingText: string;
   lastSentText: string;
-  lastSentParseMode?: "HTML";
 }
 
 export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
@@ -38,7 +27,6 @@ export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
   flushRequested?: boolean;
 }
 
-export type TelegramSentPreviewMessage = TelegramSentMessage;
 export type TelegramPreviewReplyMarkup = unknown;
 
 export interface TelegramPreviewRuntimeDeps<
@@ -61,17 +49,6 @@ export interface TelegramPreviewRuntimeDeps<
       message_thread_id?: number;
     },
   ) => Promise<unknown>;
-  sendMessage: (
-    chatId: number,
-    text: string,
-    options?: { parseMode?: "HTML" },
-  ) => Promise<TelegramSentPreviewMessage>;
-  editMessageText: (
-    chatId: number,
-    messageId: number,
-    text: string,
-    options?: { parseMode?: "HTML" },
-  ) => Promise<unknown>;
   canSend?: () => boolean;
   recordRuntimeEvent?: (
     category: string,
@@ -149,18 +126,6 @@ export interface TelegramPreviewControllerDeps<
       message_thread_id?: number;
     },
   ) => Promise<unknown>;
-  sendMessage: (
-    chatId: number,
-    text: string,
-    options: { parseMode?: "HTML" } | undefined,
-    replyToMessageId: number | undefined,
-  ) => Promise<TelegramSentPreviewMessage>;
-  editMessageText: (
-    chatId: number,
-    messageId: number,
-    text: string,
-    options?: { parseMode?: "HTML" },
-  ) => Promise<unknown>;
   canSend?: () => boolean;
   throttleMs?: number;
   maxDraftId?: number;
@@ -190,47 +155,9 @@ export interface TelegramPreviewController<
   finalize: (chatId: number, replyToMessageId?: number) => Promise<boolean>;
 }
 
-export interface TelegramPreviewMessageTransportDeps {
-  sendMessage: (body: TelegramSendMessageBody) => Promise<TelegramSentMessage>;
-  editMessageText: (body: TelegramEditMessageTextBody) => Promise<unknown>;
-  buildReplyParameters?: (
-    chatId: number,
-    replyToMessageId: number | undefined,
-  ) => TelegramReplyParameters | undefined;
-}
-
-export function createTelegramPreviewMessageTransport(
-  deps: TelegramPreviewMessageTransportDeps,
-): Pick<TelegramPreviewControllerDeps, "sendMessage" | "editMessageText"> {
-  const getReplyParameters =
-    deps.buildReplyParameters ?? buildTelegramReplyParameters;
-  return {
-    sendMessage: (chatId, text, options, replyToMessageId) => {
-      const replyParameters = getReplyParameters(chatId, replyToMessageId);
-      return deps.sendMessage({
-        chat_id: chatId,
-        text,
-        parse_mode: options?.parseMode,
-        ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-      });
-    },
-    editMessageText: (chatId, messageId, text, options) =>
-      deps.editMessageText({
-        chat_id: chatId,
-        message_id: messageId,
-        text,
-        parse_mode: options?.parseMode,
-      }),
-  };
-}
-
 export type TelegramPreviewControllerRuntimeDeps<
   TReplyMarkup = TelegramPreviewReplyMarkup,
-> = Omit<
-  TelegramPreviewControllerDeps<TReplyMarkup>,
-  "sendMessage" | "editMessageText"
-> &
-  TelegramPreviewMessageTransportDeps;
+> = TelegramPreviewControllerDeps<TReplyMarkup>;
 
 export function createTelegramPreviewControllerRuntime<
   TReplyMarkup = TelegramPreviewReplyMarkup,
@@ -242,11 +169,6 @@ export function createTelegramPreviewControllerRuntime<
     maxMessageLength: deps.maxMessageLength,
     initialDraftSupport: deps.initialDraftSupport,
     sendDraft: deps.sendDraft,
-    ...createTelegramPreviewMessageTransport({
-      sendMessage: deps.sendMessage,
-      editMessageText: deps.editMessageText,
-      buildReplyParameters: deps.buildReplyParameters,
-    }),
     throttleMs: deps.throttleMs,
     maxDraftId: deps.maxDraftId,
     setTimer: deps.setTimer,
@@ -268,12 +190,6 @@ export interface TelegramAssistantPreviewRuntimeDeps<
     markdown: string,
     options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
-  editMarkdownMessage?: (
-    chatId: number,
-    messageId: number,
-    markdown: string,
-    options?: { replyMarkup?: TReplyMarkup },
-  ) => Promise<unknown>;
 }
 
 export type TelegramAssistantPreviewRuntime<
@@ -289,26 +205,6 @@ export type TelegramAssistantPreviewRuntime<
     ) => Promise<boolean>;
   };
 
-export function createTelegramNativeMarkdownMessageEditor<TReplyMarkup>(deps: {
-  editMessageText: (body: TelegramEditMessageTextBody) => Promise<unknown>;
-}): (
-  chatId: number,
-  messageId: number,
-  markdown: string,
-  options?: { replyMarkup?: TReplyMarkup },
-) => Promise<unknown> {
-  return (chatId, messageId, markdown, options) =>
-    deps.editMessageText({
-      chat_id: chatId,
-      message_id: messageId,
-      rich_message: {
-        markdown: normalizeTelegramNativeMarkdown(markdown),
-        skip_entity_detection: true,
-      },
-      ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
-    });
-}
-
 export function createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>(deps: {
   getState: () => TelegramPreviewRuntimeState | undefined;
   clear: (chatId: number) => Promise<void>;
@@ -319,12 +215,6 @@ export function createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>(deps:
     markdown: string,
     options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
-  editMarkdownMessage?: (
-    chatId: number,
-    messageId: number,
-    markdown: string,
-    options?: { replyMarkup?: TReplyMarkup },
-  ) => Promise<unknown>;
 }): (
   chatId: number,
   markdown: string,
@@ -333,15 +223,6 @@ export function createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>(deps:
 ) => Promise<boolean> {
   return async (chatId, markdown, replyToMessageId, options) => {
     const state = deps.getState();
-    if (state?.mode === "message" && state.messageId !== undefined) {
-      try {
-        await deps.editMarkdownMessage?.(chatId, state.messageId, markdown, options);
-        await deps.clear(chatId);
-        return true;
-      } catch {
-        // Fall through to a fresh native Rich Message so final text is not lost.
-      }
-    }
     if (state?.flushPromise) {
       await state.flushPromise.catch(() => {});
     }
@@ -363,7 +244,6 @@ export function createTelegramAssistantPreviewRuntime<
     clear: controller.clear,
     discard: () => controller.setState(undefined),
     sendMarkdownReply: deps.sendMarkdownReply,
-    editMarkdownMessage: deps.editMarkdownMessage,
   });
   return {
     ...controller,
@@ -396,12 +276,10 @@ export function createTelegramPreviewController<
   const throttleMs = deps.throttleMs ?? TELEGRAM_PREVIEW_THROTTLE_MS;
   const maxDraftId = deps.maxDraftId ?? TELEGRAM_DRAFT_ID_MAX;
   const maxMessageLength =
-    deps.maxMessageLength ?? TELEGRAM_FALLBACK_PREVIEW_MESSAGE_MAX_CHARS;
+    deps.maxMessageLength ?? TELEGRAM_DRAFT_PREVIEW_MAX_CHARS;
   let draftSupport = deps.initialDraftSupport ?? "unknown";
   let nextDraftId = 0;
-  const getRuntimeDeps = (
-    replyToMessageId?: number,
-  ): TelegramPreviewRuntimeDeps<TReplyMarkup> => ({
+  const getRuntimeDeps = (): TelegramPreviewRuntimeDeps<TReplyMarkup> => ({
     getState: () => state,
     setState: (nextState) => {
       state = nextState;
@@ -421,14 +299,6 @@ export function createTelegramPreviewController<
       return nextDraftId;
     },
     sendDraft: deps.sendDraft,
-    sendMessage: (chatId, text, options) =>
-      deps.sendMessage(
-        chatId,
-        text,
-        options,
-        replyToMessageId ?? deps.getDefaultReplyToMessageId?.(),
-      ),
-    editMessageText: deps.editMessageText,
     canSend: deps.canSend,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
@@ -457,8 +327,8 @@ export function createTelegramPreviewController<
       }, throttleMs);
       state.flushTimer.unref?.();
     },
-    finalize: (chatId, replyToMessageId) =>
-      finalizeTelegramPreview(chatId, getRuntimeDeps(replyToMessageId)),
+    finalize: (chatId, _replyToMessageId) =>
+      finalizeTelegramPreview(chatId, getRuntimeDeps()),
   };
 }
 
@@ -534,9 +404,6 @@ export function buildTelegramPreviewFinalText(
 ): string | undefined {
   const finalText = state.pendingText.trim();
   if (finalText) return finalText;
-  if (state.lastSentParseMode === "HTML") {
-    return undefined;
-  }
   return state.lastSentText.trim() || undefined;
 }
 
@@ -544,7 +411,7 @@ export function createTelegramPreviewRuntimeState(
   draftSupport: TelegramDraftSupport,
 ): TelegramPreviewRuntimeState {
   return {
-    mode: draftSupport === "unsupported" ? "message" : "draft",
+    mode: "draft",
     pendingText: "",
     lastSentText: "",
   };
@@ -559,14 +426,13 @@ export function allocateTelegramDraftId(
 
 interface TelegramNativeMarkdownPreviewSnapshot {
   text: string;
-  sourceText: string;
 }
 
-export function shouldUseTelegramDraftPreview(options: {
+export function shouldUseTelegramDraftPreview(_options: {
   draftSupport: TelegramDraftSupport;
   snapshot?: TelegramNativeMarkdownPreviewSnapshot;
 }): boolean {
-  return options.draftSupport !== "unsupported";
+  return true;
 }
 
 export async function clearTelegramPreview<
@@ -598,19 +464,223 @@ export async function clearTelegramPreview<
   }
 }
 
+interface TelegramDraftInlineState {
+  codeTicks: number;
+  htmlComment: boolean;
+  displayMath: boolean;
+  fence?: { marker: "`" | "~"; length: number };
+  strongAsterisk: boolean;
+  emphasisAsterisk: boolean;
+  strongUnderscore: boolean;
+  emphasisUnderscore: boolean;
+  strike: boolean;
+  linkText: boolean;
+  linkDestination: boolean;
+}
+
+function createTelegramDraftInlineState(): TelegramDraftInlineState {
+  return {
+    codeTicks: 0,
+    htmlComment: false,
+    displayMath: false,
+    strongAsterisk: false,
+    emphasisAsterisk: false,
+    strongUnderscore: false,
+    emphasisUnderscore: false,
+    strike: false,
+    linkText: false,
+    linkDestination: false,
+  };
+}
+
+function isTelegramDraftInlineStateClosed(state: TelegramDraftInlineState): boolean {
+  return state.codeTicks === 0 &&
+    !state.htmlComment &&
+    !state.displayMath &&
+    !state.fence &&
+    !state.strongAsterisk &&
+    !state.emphasisAsterisk &&
+    !state.strongUnderscore &&
+    !state.emphasisUnderscore &&
+    !state.strike &&
+    !state.linkText &&
+    !state.linkDestination;
+}
+
+function countRepeatedChars(text: string, index: number, char: string): number {
+  let count = 0;
+  while (text[index + count] === char) count += 1;
+  return count;
+}
+
+function isEscapedMarkdownChar(text: string, index: number): boolean {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+    slashCount += 1;
+  }
+  return slashCount % 2 === 1;
+}
+
+function isInlineDelimiterCandidate(text: string, index: number, length: number): boolean {
+  const previous = text[index - 1] ?? "";
+  const next = text[index + length] ?? "";
+  if (!next || /\s/.test(next)) return previous.length > 0 && !/\s/.test(previous);
+  if (!previous || /\s/.test(previous)) return true;
+  return /[\p{P}\p{S}]/u.test(previous) || /[\p{P}\p{S}]/u.test(next);
+}
+
+function updateTelegramDraftInlineStateForLine(
+  line: string,
+  state: TelegramDraftInlineState,
+): void {
+  if (state.fence || state.displayMath) return;
+  for (let index = 0; index < line.length; index += 1) {
+    if (state.htmlComment) {
+      const closeIndex = line.indexOf("-->", index);
+      if (closeIndex === -1) return;
+      state.htmlComment = false;
+      index = closeIndex + 2;
+      continue;
+    }
+    if (state.codeTicks > 0) {
+      const ticks = countRepeatedChars(line, index, "`");
+      if (ticks >= state.codeTicks) {
+        state.codeTicks = 0;
+        index += ticks - 1;
+      }
+      continue;
+    }
+    if (isEscapedMarkdownChar(line, index)) continue;
+    if (line.startsWith("<!--", index)) {
+      const closeIndex = line.indexOf("-->", index + 4);
+      if (closeIndex === -1) {
+        state.htmlComment = true;
+        return;
+      }
+      index = closeIndex + 2;
+      continue;
+    }
+    const ticks = countRepeatedChars(line, index, "`");
+    if (ticks > 0) {
+      state.codeTicks = ticks;
+      index += ticks - 1;
+      continue;
+    }
+    if (line.startsWith("][", index) || line.startsWith("](", index)) {
+      state.linkText = false;
+      state.linkDestination = true;
+      index += 1;
+      continue;
+    }
+    if (line[index] === "[" && !state.linkDestination) {
+      state.linkText = true;
+      continue;
+    }
+    if (line[index] === ")" && state.linkDestination) {
+      state.linkDestination = false;
+      continue;
+    }
+    if (line.startsWith("~~", index) && isInlineDelimiterCandidate(line, index, 2)) {
+      state.strike = !state.strike;
+      index += 1;
+      continue;
+    }
+    if (line.startsWith("**", index) && isInlineDelimiterCandidate(line, index, 2)) {
+      state.strongAsterisk = !state.strongAsterisk;
+      index += 1;
+      continue;
+    }
+    if (line[index] === "*" && isInlineDelimiterCandidate(line, index, 1)) {
+      state.emphasisAsterisk = !state.emphasisAsterisk;
+      continue;
+    }
+    if (line.startsWith("__", index) && isInlineDelimiterCandidate(line, index, 2)) {
+      state.strongUnderscore = !state.strongUnderscore;
+      index += 1;
+      continue;
+    }
+    if (line[index] === "_" && isInlineDelimiterCandidate(line, index, 1)) {
+      state.emphasisUnderscore = !state.emphasisUnderscore;
+    }
+  }
+}
+
+function updateTelegramDraftBlockStateForLine(
+  line: string,
+  state: TelegramDraftInlineState,
+): boolean {
+  const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+  if (state.fence) {
+    if (new RegExp(`^ {0,3}${state.fence.marker}{${state.fence.length},}\\s*$`).test(line)) {
+      state.fence = undefined;
+    }
+    return true;
+  }
+  if (state.displayMath) {
+    if (line.trim() === "$$") state.displayMath = false;
+    return true;
+  }
+  if (fenceMatch) {
+    const markerText = fenceMatch[1] ?? "```";
+    state.fence = { marker: markerText[0] as "`" | "~", length: markerText.length };
+    return true;
+  }
+  if (line.trim() === "$$") {
+    state.displayMath = true;
+    return true;
+  }
+  return false;
+}
+
+function findSafeTelegramRichMarkdownDraftEnd(markdown: string): number {
+  const state = createTelegramDraftInlineState();
+  let offset = 0;
+  let safeEnd = 0;
+  for (const line of markdown.split("\n")) {
+    const lineEnd = offset + line.length;
+    const consumedAsBlock = updateTelegramDraftBlockStateForLine(line, state);
+    if (!consumedAsBlock) updateTelegramDraftInlineStateForLine(line, state);
+    const nextOffset = lineEnd + 1;
+    if (isTelegramDraftInlineStateClosed(state)) safeEnd = lineEnd;
+    offset = nextOffset;
+  }
+  if (isTelegramDraftInlineStateClosed(state)) return markdown.length;
+  return safeEnd;
+}
+
+export function getSafeTelegramRichMarkdownDraftPrefix(
+  markdown: string,
+  maxMessageLength: number,
+): string | undefined {
+  const source = markdown.trim();
+  if (!source) return undefined;
+  const limited = source.length > maxMessageLength
+    ? source.slice(0, maxMessageLength)
+    : source;
+  const safeEnd = findSafeTelegramRichMarkdownDraftEnd(limited);
+  if (safeEnd > 0) return limited.slice(0, safeEnd).trimEnd() || undefined;
+  let candidateEnd = limited.length;
+  while (candidateEnd > 0) {
+    candidateEnd = limited.lastIndexOf(" ", candidateEnd - 1);
+    if (candidateEnd <= 0) return undefined;
+    const candidate = limited.slice(0, candidateEnd).trimEnd();
+    if (findSafeTelegramRichMarkdownDraftEnd(candidate) === candidate.length) {
+      return candidate || undefined;
+    }
+  }
+  return undefined;
+}
+
 function buildTelegramNativeMarkdownPreviewSnapshot(
   state: TelegramPreviewState,
   maxMessageLength: number,
 ): TelegramNativeMarkdownPreviewSnapshot | undefined {
-  const sourceText = state.pendingText.trim();
-  if (!sourceText || sourceText === state.lastSentText) return undefined;
-  return {
-    text:
-      sourceText.length > maxMessageLength
-        ? sourceText.slice(0, maxMessageLength)
-        : sourceText,
-    sourceText,
-  };
+  const safeText = getSafeTelegramRichMarkdownDraftPrefix(
+    state.pendingText,
+    maxMessageLength,
+  );
+  if (!safeText || safeText === state.lastSentText) return undefined;
+  return { text: safeText };
 }
 
 async function performTelegramPreviewFlush<
@@ -641,29 +711,21 @@ async function performTelegramPreviewFlush<
       await deps.sendDraft(
         chatId,
         draftId,
-        normalizeTelegramNativeMarkdown(snapshot.sourceText),
+        normalizeTelegramNativeMarkdown(snapshot.text),
       );
       deps.setDraftSupport("supported");
       state.mode = "draft";
       state.lastSentText = snapshot.text;
-      state.lastSentParseMode = undefined;
       return;
-    } catch {
-      deps.setDraftSupport("unsupported");
+    } catch (error) {
+      deps.recordRuntimeEvent?.("preview", error, {
+        phase: "draft",
+        chatId,
+        draftId,
+      });
+      return;
     }
   }
-  if (state.messageId === undefined) {
-    const sent = await deps.sendMessage(chatId, snapshot.text, undefined);
-    state.messageId = sent.message_id;
-    state.mode = "message";
-    state.lastSentText = snapshot.text;
-    state.lastSentParseMode = undefined;
-    return;
-  }
-  await deps.editMessageText(chatId, state.messageId, snapshot.text, undefined);
-  state.mode = "message";
-  state.lastSentText = snapshot.text;
-  state.lastSentParseMode = undefined;
 }
 
 export async function flushTelegramPreview<
@@ -689,7 +751,7 @@ export async function flushTelegramPreview<
         deps.recordRuntimeEvent?.("preview", error, {
           phase: "flush",
           chatId,
-          messageId: state.messageId,
+          draftId: state.draftId,
         });
         break;
       }
@@ -722,11 +784,6 @@ export async function finalizeTelegramPreview<
     await clearTelegramPreview(chatId, deps);
     return false;
   }
-  if (state.mode === "draft") {
-    await deps.sendMessage(chatId, finalText);
-    deps.setState(undefined);
-    return true;
-  }
   deps.setState(undefined);
-  return state.messageId !== undefined;
+  return false;
 }

package/lib/replies.ts

@@ -286,13 +286,46 @@ function normalizeTelegramNativeMarkdownLine(line: string): string {
   return result.replace(/\u0000(\d+)\u0000/g, (_match, index) => codeSpans[Number(index)] ?? "");
 }
 
+function hasClosingDisplayMathDelimiter(lines: readonly string[], startIndex: number): boolean {
+  let fence: { marker: "`" | "~"; length: number } | undefined;
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (!fence && line.trim() === "$$") return true;
+    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;
+    }
+  }
+  return false;
+}
+
 export function normalizeTelegramNativeMarkdown(markdown: string): string {
   const lines = markdown.replace(/\r\n/g, "\n").split("\n");
   let fence: { marker: "`" | "~"; length: number } | undefined;
+  let displayMath = false;
   return lines
-    .map((line) => {
+    .map((line, index) => {
       const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
       const inFence = fence !== undefined;
+      if (!inFence && line.trim() === "$$") {
+        if (displayMath) {
+          displayMath = false;
+          return "```";
+        }
+        if (hasClosingDisplayMathDelimiter(lines, index)) {
+          displayMath = true;
+          return "```math";
+        }
+      }
+      if (displayMath) return line;
       if (!inFence && fenceMatch) {
         const markerText = fenceMatch[1] ?? "```";
         fence = { marker: markerText[0] as "`" | "~", length: markerText.length };
@@ -423,6 +456,12 @@ function countTelegramNativeMarkdownBlocks(block: string): number {
 }
 
 function splitTelegramNativeMarkdownLongBlock(block: string): string[] {
+  return splitTelegramNativeMarkdownLongFenceBlock(block) ??
+    splitTelegramNativeMarkdownLongWrappedInlineBlock(block) ??
+    splitTelegramNativeMarkdownLongPlainBlock(block);
+}
+
+function splitTelegramNativeMarkdownLongPlainBlock(block: string): string[] {
   const chunks: string[] = [];
   let remaining = block;
   while (remaining.length > TELEGRAM_RICH_MESSAGE_MAX_CHARS) {
@@ -435,8 +474,70 @@ function splitTelegramNativeMarkdownLongBlock(block: string): string[] {
   return chunks;
 }
 
-function findTelegramNativeMarkdownSplitIndex(text: string): number {
-  const hardLimit = TELEGRAM_RICH_MESSAGE_MAX_CHARS;
+function splitTelegramNativeMarkdownLongFenceBlock(block: string): string[] | undefined {
+  const lines = block.split("\n");
+  const opening = lines[0] ?? "";
+  const closing = lines[lines.length - 1] ?? "";
+  const openingMatch = opening?.match(/^ {0,3}(`{3,}|~{3,})/);
+  if (!openingMatch || !closing || lines.length < 2) return undefined;
+  const markerText = openingMatch[1] ?? "```";
+  const marker = markerText[0] as "`" | "~";
+  if (!new RegExp(`^ {0,3}${marker}{${markerText.length},}\\s*$`).test(closing)) {
+    return undefined;
+  }
+  const maxContentLength = TELEGRAM_RICH_MESSAGE_MAX_CHARS -
+    opening.length -
+    closing.length -
+    2;
+  if (maxContentLength <= 0) return undefined;
+  const content = lines.slice(1, -1).join("\n");
+  return splitTelegramNativeMarkdownWrappedContent(
+    content,
+    maxContentLength,
+    (chunk) => `${opening}\n${chunk}${chunk.endsWith("\n") ? "" : "\n"}${closing}`,
+  );
+}
+
+function splitTelegramNativeMarkdownLongWrappedInlineBlock(
+  block: string,
+): string[] | undefined {
+  const delimiter = ["**", "__", "~~", "`", "*", "_"]
+    .find((candidate) =>
+      block.startsWith(candidate) &&
+      block.endsWith(candidate) &&
+      block.length > candidate.length * 2
+    );
+  if (!delimiter) return undefined;
+  const maxContentLength = TELEGRAM_RICH_MESSAGE_MAX_CHARS - delimiter.length * 2;
+  if (maxContentLength <= 0) return undefined;
+  return splitTelegramNativeMarkdownWrappedContent(
+    block.slice(delimiter.length, -delimiter.length),
+    maxContentLength,
+    (chunk) => `${delimiter}${chunk}${delimiter}`,
+  );
+}
+
+function splitTelegramNativeMarkdownWrappedContent(
+  content: string,
+  maxContentLength: number,
+  wrap: (chunk: string) => string,
+): string[] {
+  const chunks: string[] = [];
+  let remaining = content;
+  while (remaining.length > maxContentLength) {
+    const window = remaining.slice(0, maxContentLength + 1);
+    const splitIndex = findTelegramNativeMarkdownSplitIndex(window, maxContentLength);
+    chunks.push(wrap(remaining.slice(0, splitIndex)));
+    remaining = remaining.slice(splitIndex);
+  }
+  if (remaining.length > 0) chunks.push(wrap(remaining));
+  return chunks;
+}
+
+function findTelegramNativeMarkdownSplitIndex(
+  text: string,
+  hardLimit = TELEGRAM_RICH_MESSAGE_MAX_CHARS,
+): number {
   const paragraphIndex = text.lastIndexOf("\n\n", hardLimit);
   if (paragraphIndex > 0) return paragraphIndex + 2;
   const lineIndex = text.lastIndexOf("\n", hardLimit);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "private": false,
   "publishConfig": {
     "access": "public"