@llblab/pi-kit 0.5.2 → 0.6.0

package/node_modules/@llblab/pi-telegram/lib/outbound-attachments.ts

@@ -21,7 +21,7 @@ import {
   TELEGRAM_MESSAGE_PROMPT_SNIPPET,
 } from "./prompts.ts";
 import {
-  buildTelegramMultipartReplyParameters,
+  withTelegramReplyParameters,
   normalizeTelegramNativeMarkdown,
 } from "./replies.ts";
 import {
@@ -189,18 +189,10 @@ export function planTelegramRichOutboundAttachment(options: {
     ],
     skip_entity_detection: true,
   };
-  const replyParameters =
-    options.turn.replyToMessageId > 0
-      ? JSON.stringify({
-          message_id: options.turn.replyToMessageId,
-          allow_sending_without_reply: true,
-        })
-      : undefined;
   return {
     method: "sendRichMessage",
     fields: {
       chat_id: String(options.turn.chatId),
-      ...(replyParameters ? { reply_parameters: replyParameters } : {}),
       ...getTelegramMultipartTargetFields(options.turn.target),
       rich_message: JSON.stringify(richMessage),
       ...(options.replyMarkup
@@ -230,12 +222,15 @@ export function createTelegramRichOutboundAttachmentSender(
     });
     if (!plan) return false;
     try {
-      const result = await deps.sendMultipart(
-        plan.method,
-        plan.fields,
-        plan.fileField,
-        plan.filePath,
-        plan.fileName,
+      const result = await withTelegramReplyParameters(
+        turn.chatId, turn.replyToMessageId, turn.target,
+        (replyParameters) => deps.sendMultipart(
+          plan.method,
+          { ...plan.fields, ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}) },
+          plan.fileField,
+          plan.filePath,
+          plan.fileName,
+        ),
       );
       const messageId =
         result && typeof result === "object" &&
@@ -964,21 +959,19 @@ export async function sendQueuedTelegramOutboundAttachments(
       const isPhoto = isTelegramOutboundPhotoAttachmentPath(attachment.path);
       const method = isPhoto ? "sendPhoto" : "sendDocument";
       const fieldName = isPhoto ? "photo" : "document";
-      const replyParameters = buildTelegramMultipartReplyParameters(
-        turn.chatId,
-        turn.replyToMessageId,
-        turn.target,
-      );
-      await deps.sendMultipart(
-        method,
-        {
-          chat_id: String(turn.chatId),
-          ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-          ...getTelegramMultipartTargetFields(turn.target),
-        },
-        fieldName,
-        attachment.path,
-        attachment.fileName,
+      await withTelegramReplyParameters(
+        turn.chatId, turn.replyToMessageId, turn.target,
+        (replyParameters) => deps.sendMultipart(
+          method,
+          {
+            chat_id: String(turn.chatId),
+            ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}),
+            ...getTelegramMultipartTargetFields(turn.target),
+          },
+          fieldName,
+          attachment.path,
+          attachment.fileName,
+        ),
       );
     } catch (error) {
       if (deps.isDeliveryActive?.() === false) return;

package/node_modules/@llblab/pi-telegram/lib/outbound-voice.ts

@@ -8,7 +8,7 @@ import { unlink } from "node:fs/promises";
 import { basename, extname } from "node:path";
 
 import { assertTelegramInlineKeyboardCallbackData } from "./keyboard.ts";
-import { buildTelegramMultipartReplyParameters } from "./replies.ts";
+import { withTelegramReplyParameters } from "./replies.ts";
 import {
   getTelegramTargetThreadParams,
   type TelegramTarget,
@@ -80,17 +80,6 @@ export interface TelegramVoiceReplySenderPorts<THandler = unknown> {
   getProgrammaticVoiceHandlers?: () => TelegramOutboundProgrammaticVoiceHandler[];
 }
 
-function buildVoiceReplyParameters(
-  chatId: number,
-  replyToPrompt: boolean | undefined,
-  replyToMessageId: number | undefined,
-  target?: TelegramTarget,
-): string | undefined {
-  if (replyToPrompt === false || replyToMessageId === undefined)
-    return undefined;
-  return buildTelegramMultipartReplyParameters(chatId, replyToMessageId, target);
-}
-
 async function ensureTelegramVoiceFileFormat(
   filePath: string,
 ): Promise<string> {
@@ -131,36 +120,33 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
     if (deps.isDeliveryActive?.() === false) return;
     await sendVoiceChatAction(deps, turn.chatId);
     if (deps.isDeliveryActive?.() === false) return;
-    const replyParameters = buildVoiceReplyParameters(
-      turn.chatId,
-      options?.replyToPrompt,
-      turn.replyToMessageId,
-      turn.target,
-    );
-    await deps.sendMultipart(
-      "sendVoice",
-      {
-        chat_id: String(turn.chatId),
-        ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-        ...(turn.target
-          ? Object.fromEntries(
-              Object.entries(getTelegramTargetThreadParams(turn.target)).map(
-                ([key, value]) => [key, String(value)],
-              ),
-            )
-          : {}),
-        ...(options?.replyMarkup !== undefined && options.replyMarkup !== null
-          ? {
-              reply_markup:
-                typeof options.replyMarkup === "string"
-                  ? options.replyMarkup
-                  : JSON.stringify(options.replyMarkup),
-            }
-          : {}),
-      },
-      "voice",
-      voiceFilePath,
-      basename(voiceFilePath),
+    await withTelegramReplyParameters(
+      turn.chatId, options?.replyToPrompt === false ? undefined : turn.replyToMessageId, turn.target,
+      (replyParameters) => deps.sendMultipart(
+        "sendVoice",
+        {
+          chat_id: String(turn.chatId),
+          ...(replyParameters ? { reply_parameters: JSON.stringify(replyParameters) } : {}),
+          ...(turn.target
+            ? Object.fromEntries(
+                Object.entries(getTelegramTargetThreadParams(turn.target)).map(
+                  ([key, value]) => [key, String(value)],
+                ),
+              )
+            : {}),
+          ...(options?.replyMarkup !== undefined && options.replyMarkup !== null
+            ? {
+                reply_markup:
+                  typeof options.replyMarkup === "string"
+                    ? options.replyMarkup
+                    : JSON.stringify(options.replyMarkup),
+              }
+            : {}),
+        },
+        "voice",
+        voiceFilePath,
+        basename(voiceFilePath),
+      ),
     );
   };
 

package/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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;