@llblab/pi-telegram 0.43.2 → 0.44.0

package/lib/outbound.ts

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import type { TelegramAssistantSegmentEvent } from "./activity.ts";
 import { resolveTelegramTempDir } from "./paths.ts";
 import * as Replies from "./replies.ts";
+import type { TelegramPreparedPreviewDelivery } from "./preview.ts";
 import { isTelegramApiCommitUnknownError } from "./telegram-api.ts";
 import type {
   TelegramEditMessageTextBody,
@@ -249,12 +250,8 @@ export interface TelegramOutboundTextPreviewRuntimeDeps<
 > {
   execCommand: TelegramVoiceReplySenderDeps["execCommand"];
   getHandlers?: () => TelegramOutboundHandlerConfig[] | undefined;
-  finalizeMarkdownPreview: (
-    chatId: number,
-    markdown: string,
-    replyToMessageId: number,
-    options?: { replyMarkup?: TReplyMarkup },
-  ) => Promise<boolean>;
+  finalizeMarkdownPreview: TelegramPreparedPreviewDelivery<TReplyMarkup>["finalizeMarkdownPreview"];
+  preparePreviewDelivery?: (isDeliveryActive: () => boolean) => TelegramPreparedPreviewDelivery<TReplyMarkup>;
   cwd?: string;
   recordRuntimeEvent?: TelegramVoiceReplySenderDeps["recordRuntimeEvent"];
 }
@@ -729,12 +726,13 @@ export function createTelegramOutboundTextPreviewRuntime<
   TReplyMarkup = unknown,
 >(
   deps: TelegramOutboundTextPreviewRuntimeDeps<TReplyMarkup>,
-): Pick<
-  TelegramOutboundTextPreviewRuntimeDeps<TReplyMarkup>,
-  "finalizeMarkdownPreview"
-> {
-  return {
-    finalizeMarkdownPreview: async (
+): {
+  finalizeMarkdownPreview: TelegramPreparedPreviewDelivery<TReplyMarkup>["finalizeMarkdownPreview"];
+  preparePreviewDelivery: (isDeliveryActive: () => boolean) => TelegramPreparedPreviewDelivery<TReplyMarkup> | undefined;
+} {
+  const wrap = (
+    finalize: TelegramPreparedPreviewDelivery<TReplyMarkup>["finalizeMarkdownPreview"],
+  ): TelegramPreparedPreviewDelivery<TReplyMarkup>["finalizeMarkdownPreview"] => async (
       chatId,
       markdown,
       replyToMessageId,
@@ -747,7 +745,7 @@ export function createTelegramOutboundTextPreviewRuntime<
         recordRuntimeEvent: deps.recordRuntimeEvent,
         replyMarkup: options?.replyMarkup,
       });
-      return deps.finalizeMarkdownPreview(
+      return finalize(
         chatId,
         transformed.text,
         replyToMessageId,
@@ -758,6 +756,12 @@ export function createTelegramOutboundTextPreviewRuntime<
             : {}),
         },
       );
+    };
+  return {
+    finalizeMarkdownPreview: wrap(deps.finalizeMarkdownPreview),
+    preparePreviewDelivery(isDeliveryActive) {
+      const prepared = deps.preparePreviewDelivery?.(isDeliveryActive);
+      return prepared ? { ...prepared, finalizeMarkdownPreview: wrap(prepared.finalizeMarkdownPreview) } : undefined;
     },
   };
 }
@@ -1018,7 +1022,7 @@ export function createTelegramAssistantOutputSender<
     };
     await outboundRuntime.sendMarkdownReply(
       target.chatId,
-      undefined,
+      event.source === "telegram" ? event.replyToMessageId : undefined,
       buttonReply.markdown,
       {
         target,

package/lib/preview.ts

@@ -5,7 +5,8 @@
  */
 
 import { normalizeTelegramNativeMarkdown } from "./replies.ts";
-import { stripTelegramCommentMarkupForPreview } from "./outbound.ts";
+import type { TelegramAssistantOutputPreparation } from "./activity.ts";
+import { stripTelegramCommentMarkupForPreview } from "./outbound-markup.ts";
 import {
   getTelegramTargetThreadParams,
   type TelegramTarget,
@@ -14,6 +15,7 @@ import { shouldSuppressPreviewForVoice } from "./voice.ts";
 
 const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
 const TELEGRAM_DRAFT_PREVIEW_MAX_CHARS = 4096;
+const TELEGRAM_DRAFT_INTERVAL_MS = 2_000;
 
 export type TelegramDraftSupport = "unknown" | "supported";
 
@@ -27,6 +29,11 @@ export interface TelegramPreviewState {
 export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
   flushPromise?: Promise<void>;
   flushRequested?: boolean;
+  precedingFlush?: Promise<void>;
+  publicationPromise?: Promise<void>;
+  sealed?: boolean;
+  nextDraftAt?: number;
+  flushTimer?: ReturnType<typeof setTimeout>;
 }
 
 export type TelegramPreviewReplyMarkup = unknown;
@@ -35,6 +42,7 @@ export interface TelegramPreviewRuntimeDeps {
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
   maxMessageLength: number;
+  minDraftIntervalMs?: number;
   getDraftSupport: () => TelegramDraftSupport;
   setDraftSupport: (support: TelegramDraftSupport) => void;
   allocateDraftId: () => number;
@@ -64,23 +72,13 @@ export interface TelegramPreviewActiveTurn {
   voiceReplyRequired?: boolean;
 }
 
-export interface TelegramAssistantMessagePreviewStartDeps<
-  TMessage,
-  TReplyMarkup = TelegramPreviewReplyMarkup,
-> {
+export interface TelegramAssistantMessagePreviewStartDeps<TMessage> {
   getActiveTurn: () => TelegramPreviewActiveTurn | undefined;
   isAssistantMessage: (message: TMessage) => boolean;
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
   createPreviewState: () => TelegramPreviewRuntimeState;
   canSend?: () => boolean;
-  finalizePreview: (chatId: number) => Promise<boolean>;
-  finalizeMarkdownPreview: (
-    chatId: number,
-    markdown: string,
-    replyToMessageId?: number,
-    options?: { replyMarkup?: TReplyMarkup; target?: TelegramTarget },
-  ) => Promise<boolean>;
 }
 
 export interface TelegramAssistantMessagePreviewUpdateDeps<TMessage> {
@@ -97,10 +95,7 @@ export interface TelegramAssistantMessagePreviewUpdateDeps<TMessage> {
   ) => void;
 }
 
-export type TelegramAssistantMessagePreviewHookDeps<
-  TMessage,
-  TReplyMarkup = TelegramPreviewReplyMarkup,
-> = TelegramAssistantMessagePreviewStartDeps<TMessage, TReplyMarkup> &
+export type TelegramAssistantMessagePreviewHookDeps<TMessage> = TelegramAssistantMessagePreviewStartDeps<TMessage> &
   TelegramAssistantMessagePreviewUpdateDeps<TMessage>;
 
 export interface TelegramAssistantMessagePreviewHookEvent<TMessage> {
@@ -140,6 +135,8 @@ export interface TelegramPreviewControllerDeps {
 }
 
 export interface TelegramPreviewController {
+  seal: () => void;
+  preparePublication: () => TelegramAssistantOutputPreparation | undefined;
   prepareClear: (
     chatId: number,
     options?: { target?: TelegramTarget; isDeliveryActive?: () => boolean },
@@ -201,11 +198,18 @@ export interface TelegramAssistantPreviewRuntimeDeps<
   ) => Promise<number | undefined>;
 }
 
+export interface TelegramPreparedPreviewDelivery<TReplyMarkup = unknown> {
+  clearPreview: TelegramPreviewController["clear"];
+  setPreviewPendingText: TelegramPreviewController["setPendingText"];
+  finalizeMarkdownPreview: ReturnType<typeof createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>>;
+}
+
 export type TelegramAssistantPreviewRuntime<
   TMessage,
   TReplyMarkup = TelegramPreviewReplyMarkup,
 > = TelegramPreviewController &
   TelegramAssistantMessagePreviewHooks<TMessage> & {
+    prepareDelivery: (isDeliveryActive: () => boolean) => TelegramPreparedPreviewDelivery<TReplyMarkup>;
     finalizeMarkdown: (
       chatId: number,
       markdown: string,
@@ -214,6 +218,14 @@ export type TelegramAssistantPreviewRuntime<
     ) => Promise<boolean>;
   };
 
+function sealTelegramPreviewState(state: TelegramPreviewRuntimeState | undefined): void {
+  if (!state) return;
+  state.sealed = true;
+  state.flushRequested = false;
+  if (state.flushTimer) clearTimeout(state.flushTimer);
+  state.flushTimer = undefined;
+}
+
 export function createTelegramNativeMarkdownPreviewFinalizer<
   TReplyMarkup,
 >(deps: {
@@ -223,6 +235,7 @@ export function createTelegramNativeMarkdownPreviewFinalizer<
     options?: { awaitFlush?: boolean; target?: TelegramTarget },
   ) => Promise<void>;
   discard?: () => void;
+  isDeliveryActive?: () => boolean;
   sendMarkdownReply: (
     chatId: number,
     replyToMessageId: number | undefined,
@@ -235,14 +248,21 @@ export function createTelegramNativeMarkdownPreviewFinalizer<
   replyToMessageId?: number,
   options?: { replyMarkup?: TReplyMarkup; target?: TelegramTarget },
 ) => Promise<boolean> {
+  return (...args) => prepareTelegramNativeMarkdownPreviewFinalizer(deps)(...args);
+}
+
+function prepareTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>(
+  deps: Parameters<typeof createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>>[0],
+): ReturnType<typeof createTelegramNativeMarkdownPreviewFinalizer<TReplyMarkup>> {
+  const state = deps.getState();
+  sealTelegramPreviewState(state);
+  const inFlight = state?.flushPromise ?? state?.precedingFlush;
   return async (chatId, markdown, replyToMessageId, options) => {
-    const state = deps.getState();
-    if (state?.flushPromise) {
-      await state.flushPromise.catch(() => {});
-      if (deps.getState() !== state) return false;
-    }
+    if (deps.isDeliveryActive?.() === false) return false;
+    await inFlight?.catch(() => {});
+    if (deps.getState() !== state || deps.isDeliveryActive?.() === false) return false;
     await deps.sendMarkdownReply(chatId, replyToMessageId, markdown, options);
-    if (deps.getState() === state) deps.discard?.();
+    if (deps.getState() === state && deps.isDeliveryActive?.() !== false) deps.discard?.();
     return true;
   };
 }
@@ -254,15 +274,28 @@ export function createTelegramAssistantPreviewRuntime<
   deps: TelegramAssistantPreviewRuntimeDeps<TMessage, TReplyMarkup>,
 ): TelegramAssistantPreviewRuntime<TMessage, TReplyMarkup> {
   const controller = createTelegramPreviewControllerRuntime(deps);
-  const finalizeMarkdownPreview = createTelegramNativeMarkdownPreviewFinalizer({
+  const finalizerDeps = {
     getState: controller.getState,
     clear: controller.clear,
     discard: () => controller.setState(undefined),
     sendMarkdownReply: deps.sendMarkdownReply,
-  });
+  };
   return {
     ...controller,
-    finalizeMarkdown: finalizeMarkdownPreview,
+    finalizeMarkdown: createTelegramNativeMarkdownPreviewFinalizer(finalizerDeps),
+    prepareDelivery(isDeliveryActive) {
+      const state = controller.getState();
+      return {
+        setPreviewPendingText(text) {
+          if (controller.getState() === state && isDeliveryActive()) controller.setPendingText(text);
+        },
+        clearPreview: async (chatId, options) => {
+          if (controller.getState() !== state || !isDeliveryActive()) return;
+          await controller.prepareClear(chatId, { ...options, isDeliveryActive })();
+        },
+        finalizeMarkdownPreview: prepareTelegramNativeMarkdownPreviewFinalizer({ ...finalizerDeps, isDeliveryActive }),
+      };
+    },
     ...createTelegramAssistantMessagePreviewHooks({
       getActiveTurn: deps.getActiveTurn,
       isAssistantMessage: deps.isAssistantMessage,
@@ -270,8 +303,6 @@ export function createTelegramAssistantPreviewRuntime<
       setState: controller.setState,
       createPreviewState: controller.createState,
       canSend: deps.canSend,
-      finalizePreview: controller.finalize,
-      finalizeMarkdownPreview,
       getMessageText: deps.getMessageText,
       schedulePreviewFlush: controller.scheduleFlush,
     }),
@@ -288,14 +319,17 @@ export function createTelegramPreviewController(
     deps.maxMessageLength ?? TELEGRAM_DRAFT_PREVIEW_MAX_CHARS;
   let draftSupport = deps.initialDraftSupport ?? "unknown";
   let nextDraftId = 0;
+  const setState = (nextState: TelegramPreviewRuntimeState | undefined): void => {
+    if (state !== nextState) sealTelegramPreviewState(state);
+    state = nextState;
+  };
   const getRuntimeDeps = (
     operationGeneration = generation,
   ): TelegramPreviewRuntimeDeps => ({
     getState: () => state,
-    setState: (nextState) => {
-      state = nextState;
-    },
+    setState,
     maxMessageLength,
+    minDraftIntervalMs: TELEGRAM_DRAFT_INTERVAL_MS,
     getDraftSupport: () => draftSupport,
     setDraftSupport: (support) => {
       draftSupport = support;
@@ -311,20 +345,27 @@ export function createTelegramPreviewController(
   });
   return {
     getState: () => state,
-    setState: (nextState) => {
-      state = nextState;
-    },
+    setState,
     setPendingText: (text) => {
       if (state) state.pendingText = text;
     },
     createState: () => createTelegramPreviewRuntimeState(),
     resetState: () => {
       generation += 1;
-      state = createTelegramPreviewRuntimeState();
+      setState({ ...createTelegramPreviewRuntimeState(), nextDraftAt: state?.nextDraftAt });
     },
     invalidate: () => {
       generation += 1;
-      state = undefined;
+      setState(undefined);
+    },
+    seal: () => sealTelegramPreviewState(state),
+    preparePublication: () => {
+      if (!state) return undefined;
+      sealTelegramPreviewState(state);
+      const prior = state.publicationPromise ?? state.flushPromise ?? state.precedingFlush;
+      let settle!: () => void;
+      state.publicationPromise = new Promise<void>((resolve) => { settle = resolve; });
+      return { wait: async () => { await prior?.catch(() => {}); }, settle };
     },
     prepareClear: (chatId, options) => {
       const admittedState = state;
@@ -350,11 +391,8 @@ export function createTelegramPreviewController(
   };
 }
 
-export function createTelegramAssistantMessagePreviewHooks<
-  TMessage,
-  TReplyMarkup = TelegramPreviewReplyMarkup,
->(
-  deps: TelegramAssistantMessagePreviewHookDeps<TMessage, TReplyMarkup>,
+export function createTelegramAssistantMessagePreviewHooks<TMessage>(
+  deps: TelegramAssistantMessagePreviewHookDeps<TMessage>,
 ): TelegramAssistantMessagePreviewHooks<TMessage> {
   return {
     onMessageStart: async (
@@ -370,12 +408,9 @@ export function createTelegramAssistantMessagePreviewHooks<
   };
 }
 
-export async function handleTelegramAssistantMessagePreviewStart<
-  TMessage,
-  TReplyMarkup = TelegramPreviewReplyMarkup,
->(
+export async function handleTelegramAssistantMessagePreviewStart<TMessage>(
   message: TMessage,
-  deps: TelegramAssistantMessagePreviewStartDeps<TMessage, TReplyMarkup>,
+  deps: TelegramAssistantMessagePreviewStartDeps<TMessage>,
 ): Promise<void> {
   const turn = deps.getActiveTurn();
   if (!turn || !deps.isAssistantMessage(message)) return;
@@ -388,26 +423,13 @@ export async function handleTelegramAssistantMessagePreviewStart<
     return;
   }
   const state = deps.getState();
-  if (
-    state &&
-    (state.pendingText.trim().length > 0 ||
-      state.lastSentText.trim().length > 0)
-  ) {
-    const previousText = state.pendingText.trim();
-    if (previousText.length > 0) {
-      await deps.finalizeMarkdownPreview(
-        turn.chatId,
-        previousText,
-        turn.replyToMessageId,
-        {
-          target: turn.target,
-        },
-      );
-    } else {
-      await deps.finalizePreview(turn.chatId);
-    }
-  }
-  deps.setState(deps.createPreviewState());
+  sealTelegramPreviewState(state);
+  const next = deps.createPreviewState();
+  // Carry the previous delivery boundary; permanent text remains with its publication owner.
+  next.draftId = state?.draftId;
+  next.nextDraftAt = state?.nextDraftAt;
+  next.precedingFlush = state?.publicationPromise ?? state?.flushPromise ?? state?.precedingFlush;
+  deps.setState(next);
 }
 
 export async function handleTelegramAssistantMessagePreviewUpdate<TMessage>(
@@ -426,6 +448,7 @@ export async function handleTelegramAssistantMessagePreviewUpdate<TMessage>(
     state = deps.createPreviewState();
     deps.setState(state);
   }
+  if (state.sealed) return;
   state.pendingText = stripTelegramCommentMarkupForPreview(
     deps.getMessageText(message),
   );
@@ -473,9 +496,11 @@ export async function clearTelegramPreview(
 ): Promise<void> {
   const state = deps.getState();
   if (!state || options.isDeliveryActive?.() === false) return;
-  if (state.flushPromise && options.awaitFlush !== false) {
+  sealTelegramPreviewState(state);
+  const inFlight = state.flushPromise ?? state.precedingFlush;
+  if (inFlight && options.awaitFlush !== false) {
     state.flushRequested = false;
-    await state.flushPromise.catch(() => {});
+    await inFlight.catch(() => {});
     if (deps.getState() !== state) return;
   }
   if (options.isDeliveryActive?.() === false) return;
@@ -782,13 +807,15 @@ async function performTelegramPreviewFlush(
   ) {
     const draftId = state.draftId ?? deps.allocateDraftId();
     state.draftId = draftId;
+    state.nextDraftAt = Date.now() + (deps.minDraftIntervalMs ?? 0);
     try {
-      await deps.sendDraft(
+      const delivered = await deps.sendDraft(
         chatId,
         draftId,
         normalizeTelegramNativeMarkdown(snapshot.text),
         { ...getTelegramTargetThreadParams(options.target ?? { chatId }) },
       );
+      if (delivered === false || deps.getState() !== state || deps.canSend?.() === false) return;
       deps.setDraftSupport("supported");
       state.mode = "draft";
       state.lastSentText = snapshot.text;
@@ -810,15 +837,33 @@ export async function flushTelegramPreview(
   options: { target?: TelegramTarget } = {},
 ): Promise<void> {
   const state = deps.getState();
-  if (!state) return;
+  if (!state || state.sealed) return;
   if (state.flushPromise) {
     state.flushRequested = true;
     await state.flushPromise;
     return;
   }
   state.flushPromise = (async () => {
+    if (state.precedingFlush) {
+      await state.precedingFlush.catch(() => {});
+      state.precedingFlush = undefined;
+      if (deps.getState() !== state || state.sealed) return;
+    }
     do {
       state.flushRequested = false;
+      const delay = (state.nextDraftAt ?? 0) - Date.now();
+      if (delay > 0) {
+        if (!state.flushTimer) {
+          state.flushTimer = setTimeout(() => {
+            state.flushTimer = undefined;
+            if (deps.getState() === state && !state.sealed) void flushTelegramPreview(chatId, deps, options);
+          }, delay);
+          state.flushTimer.unref?.();
+        }
+        break;
+      }
+      if (state.flushTimer) clearTimeout(state.flushTimer);
+      state.flushTimer = undefined;
       try {
         await performTelegramPreviewFlush(chatId, state, deps, options);
       } catch (error) {
@@ -829,7 +874,7 @@ export async function flushTelegramPreview(
         });
         break;
       }
-    } while (deps.getState() === state && state.flushRequested);
+    } while (deps.getState() === state && !state.sealed && state.flushRequested);
   })();
   try {
     await state.flushPromise;

package/lib/queue.ts

@@ -1498,6 +1498,10 @@ export interface TelegramAgentEndRuntimeDeps<
   updateStatus: () => void;
   dispatchNextQueuedTelegramTurn: () => void;
   scheduleActiveTurnDelivery?: (task: () => Promise<void>) => void;
+  preparePreviewDelivery?: (isDeliveryActive: () => boolean) => Pick<
+    TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>,
+    "clearPreview" | "setPreviewPendingText" | "finalizeMarkdownPreview"
+  > | undefined;
   preparePreviewClear?: (
     chatId: number,
     options?: { target?: TelegramQueueTarget; isDeliveryActive?: () => boolean },
@@ -1595,6 +1599,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
     schedule: (task: () => Promise<void>) => void;
     cancel: () => void;
   };
+  preparePreviewDelivery?: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>["preparePreviewDelivery"];
   preparePreviewClear?: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>["preparePreviewClear"];
   clearPreview: TelegramAgentEndRuntimeDeps<
     TTurn,
@@ -1746,6 +1751,7 @@ export function createTelegramAgentEndHook<
                 await task();
               })
           : undefined,
+        preparePreviewDelivery: deps.preparePreviewDelivery,
         preparePreviewClear: deps.preparePreviewClear,
         clearPreview: deps.clearPreview,
         setPreviewPendingText: deps.setPreviewPendingText,
@@ -1807,9 +1813,13 @@ export async function handleTelegramAgentEndRuntime<
   const isDeliveryActive = (): boolean =>
     deps.isSessionActive?.() !== false &&
     (!turn || deps.isTurnTransportActive?.(turn) !== false);
+  const preview = turn && !turn.guestQueryId ? deps.preparePreviewDelivery?.(isDeliveryActive) : undefined;
+  const setPreviewPendingText = preview?.setPreviewPendingText ?? deps.setPreviewPendingText;
+  const finalizeMarkdownPreview = preview?.finalizeMarkdownPreview ?? deps.finalizeMarkdownPreview;
   const clearPreview = turn
-    ? deps.preparePreviewClear?.(turn.chatId, { target: turn.target, isDeliveryActive })
-      ?? (() => deps.clearPreview(turn.chatId, { target: turn.target }))
+    ? preview ? () => preview.clearPreview(turn.chatId, { target: turn.target })
+      : deps.preparePreviewClear?.(turn.chatId, { target: turn.target, isDeliveryActive })
+        ?? (() => deps.clearPreview(turn.chatId, { target: turn.target }))
     : undefined;
   const updateStatusIgnoringStaleContext = (): void => {
     try {
@@ -1914,7 +1924,7 @@ export async function handleTelegramAgentEndRuntime<
       if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
       return;
     }
-    if (finalText) deps.setPreviewPendingText(finalText);
+    if (finalText) setPreviewPendingText(finalText);
 
     if (!isDeliveryActive()) return;
     let richAttachmentDelivered = false;
@@ -1932,9 +1942,9 @@ export async function handleTelegramAgentEndRuntime<
         );
         if (!isDeliveryActive()) return;
         if (richAttachmentDelivered) {
-          await deps.clearPreview(turn.chatId, { target: turn.target });
+          await clearPreview?.();
           if (!isDeliveryActive()) return;
-          deps.setPreviewPendingText("");
+          setPreviewPendingText("");
         }
       } catch (error) {
         if (!isDeliveryActive()) return;
@@ -1949,7 +1959,7 @@ export async function handleTelegramAgentEndRuntime<
     if (!isDeliveryActive()) return;
     if (!richAttachmentDelivered && endPlan.kind === "text" && finalText) {
       try {
-        const finalized = await deps.finalizeMarkdownPreview(
+        const finalized = await finalizeMarkdownPreview(
           turn.chatId,
           finalText,
           turn.replyToMessageId,
@@ -1957,7 +1967,7 @@ export async function handleTelegramAgentEndRuntime<
         );
         if (!isDeliveryActive()) return;
         if (!finalized) {
-          await deps.clearPreview(turn.chatId, { target: turn.target });
+          await clearPreview?.();
           if (!isDeliveryActive()) return;
           await deps.sendMarkdownReply(
             turn.chatId,
@@ -1967,7 +1977,7 @@ export async function handleTelegramAgentEndRuntime<
           );
         }
         if (!isDeliveryActive()) return;
-        deps.setPreviewPendingText("");
+        setPreviewPendingText("");
       } catch (error) {
         deps.recordRuntimeEvent?.("delivery", error, {
           phase: "final-text",

package/lib/replies.ts

@@ -9,6 +9,7 @@ import {
   getTelegramTargetThreadParams,
   type TelegramTarget,
 } from "./target.ts";
+import { isTelegramApiCommitUnknownError } from "./telegram-api.ts";
 import type {
   TelegramInputRichMessage,
   TelegramReplyParameters,
@@ -67,6 +68,7 @@ export function createReplyDedupRuntime(): ReplyDedupRuntime {
 // --- Transport-level dedup ---
 
 const lastRepliedToMessageIdByTarget = new Map<string, number>();
+let replyDedupGeneration = 0;
 
 function getReplyDedupTargetKey(
   chatId: number,
@@ -79,6 +81,7 @@ function getReplyDedupTargetKey(
 }
 
 export function resetTransportReplyDedup(): void {
+  replyDedupGeneration += 1;
   lastRepliedToMessageIdByTarget.clear();
 }
 
@@ -99,13 +102,29 @@ export function buildTelegramReplyParameters(
   };
 }
 
-export function buildTelegramMultipartReplyParameters(
+// Answer publications are caller-serialized. A rejected send releases its anchor;
+// an uncertain ACK retains it because Telegram may already have delivered it.
+export async function withTelegramReplyParameters<T>(
   chatId: number,
   messageId: number | undefined,
-  target?: TelegramTarget,
-): string | undefined {
+  target: TelegramTarget | undefined,
+  send: (parameters: TelegramReplyParameters | undefined) => Promise<T>,
+): Promise<T> {
+  const key = getReplyDedupTargetKey(chatId, target);
+  const generation = replyDedupGeneration;
+  const previous = lastRepliedToMessageIdByTarget.get(key);
   const parameters = buildTelegramReplyParameters(chatId, messageId, target);
-  return parameters ? JSON.stringify(parameters) : undefined;
+  try {
+    return await send(parameters);
+  } catch (error) {
+    if (parameters && !isTelegramApiCommitUnknownError(error)
+      && generation === replyDedupGeneration
+      && lastRepliedToMessageIdByTarget.get(key) === messageId) {
+      if (previous === undefined) lastRepliedToMessageIdByTarget.delete(key);
+      else lastRepliedToMessageIdByTarget.set(key, previous);
+    }
+    throw error;
+  }
 }
 
 function getAgentMessageField(message: unknown, field: string): unknown {
@@ -239,24 +258,18 @@ export async function sendTelegramRenderedChunks<TReplyMarkup>(
   assertTelegramInlineKeyboardCallbackData(options?.replyMarkup);
   let lastMessageId: number | undefined;
   for (const [index, chunk] of chunks.entries()) {
-    const replyParameters =
-      index === 0
-        ? buildTelegramReplyParameters(
-            chatId,
-            options?.replyToMessageId,
-            options?.target,
-          )
-        : undefined;
-    const body = {
-      chat_id: chatId,
-      text: chunk.text,
-      parse_mode: chunk.parseMode,
-      reply_markup:
-        index === chunks.length - 1 ? options?.replyMarkup : undefined,
-      ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-      ...(options?.target ? getTelegramTargetThreadParams(options.target) : {}),
-    };
-    const sent = await deps.sendMessage(body);
+    const sent = await withTelegramReplyParameters(
+      chatId, index === 0 ? options?.replyToMessageId : undefined, options?.target,
+      (replyParameters) => deps.sendMessage({
+        chat_id: chatId,
+        text: chunk.text,
+        parse_mode: chunk.parseMode,
+        reply_markup:
+          index === chunks.length - 1 ? options?.replyMarkup : undefined,
+        ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+        ...(options?.target ? getTelegramTargetThreadParams(options.target) : {}),
+      }),
+    );
     lastMessageId = sent.message_id;
     deps.recordOwnership?.({
       chatId,
@@ -655,22 +668,17 @@ export async function sendTelegramNativeMarkdownReply<TReplyMarkup = unknown>(
   let lastMessageId: number | undefined;
   const chunks = splitTelegramNativeMarkdown(markdown);
   for (const [index, chunk] of chunks.entries()) {
-    const replyParameters =
-      index === 0
-        ? buildTelegramReplyParameters(
-            chatId,
-            replyToMessageId,
-            options?.target,
-          )
-        : 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 } : {}),
-      ...(options?.target ? getTelegramTargetThreadParams(options.target) : {}),
-    });
+    const sent = await withTelegramReplyParameters(
+      chatId, index === 0 ? replyToMessageId : undefined, options?.target,
+      (replyParameters) => 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 } : {}),
+        ...(options?.target ? getTelegramTargetThreadParams(options.target) : {}),
+      }),
+    );
     lastMessageId = sent.message_id;
     deps.recordOwnership?.({
       chatId,