@llblab/pi-kit 0.5.1 → 0.5.2

package/node_modules/@llblab/pi-telegram/lib/bindings.ts

@@ -353,6 +353,7 @@ export function createTelegramAssistantOutputBindingRuntime<
     typeof OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>
   >[0];
   waitForActivityIdle?: () => Promise<void>;
+  enqueue?: Activity.TelegramActivityPublicationRuntime["enqueue"];
   recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }): TelegramAssistantOutputBindingRuntime<TTransportStamp> {
   const authority = Routing.createTelegramAssistantOutputAuthorityRuntime(
@@ -364,6 +365,7 @@ export function createTelegramAssistantOutputBindingRuntime<
     );
   const runtime = Activity.createTelegramAssistantOutputRuntime({
     ...authority,
+    enqueue: deps.enqueue,
     async send(event, authority, isAuthorityActive) {
       await deps.waitForActivityIdle?.();
       if (!isAuthorityActive()) return;
@@ -390,7 +392,14 @@ type TelegramAssistantOutputAuthority<TTransportStamp> = ReturnType<
   Routing.TelegramAssistantOutputAuthorityRuntime<TTransportStamp>["captureAuthority"]
 >;
 
+export interface TelegramBridgePublicationRuntime {
+  enqueue: Activity.TelegramActivityPublicationRuntime["enqueue"];
+  reserve: Activity.TelegramActivityPublicationRuntime["reserve"];
+  capture: () => { target?: Queue.TelegramQueueTarget; isCurrent: () => boolean };
+}
+
 export interface TelegramActivityBindingRuntime {
+  publicationRuntime: TelegramBridgePublicationRuntime;
   activityRuntime: Activity.TelegramActivityRuntime;
   activityVerbosityRuntime: ActivityVerbosity.TelegramActivityVerbosityRuntime;
   assistantOutputRuntime: Activity.TelegramAssistantOutputRuntime;
@@ -403,7 +412,7 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     Parameters<
       typeof createTelegramAssistantOutputBindingRuntime<TTransportStamp>
     >[0],
-    "waitForActivityIdle"
+    "waitForActivityIdle" | "enqueue"
   >;
   activityVerbosity: Omit<
     Parameters<
@@ -411,19 +420,19 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
         TelegramAssistantOutputAuthority<TTransportStamp>
       >
     >[0],
-    "captureAuthority" | "isAuthorityActive" | "recordFailure"
+    "captureAuthority" | "isAuthorityActive" | "recordFailure" | "enqueue"
   >;
 }): TelegramActivityBindingRuntime {
-  const activityVerbosityBinding =
-    ActivityVerbosity.createTelegramActivityVerbosityBinding();
+  const publication = Activity.createTelegramActivityPublicationRuntime();
   const assistantOutputBinding =
     createTelegramAssistantOutputBindingRuntime({
       ...deps.assistantOutput,
-      waitForActivityIdle: activityVerbosityBinding.waitForIdle,
+      enqueue: publication.enqueue,
     });
   const activityVerbosityRuntime =
     ActivityVerbosity.createTelegramActivityVerbosityRuntime({
       ...deps.activityVerbosity,
+      enqueue: publication.enqueue,
       captureAuthority: assistantOutputBinding.authority.captureAuthority,
       isAuthorityActive: assistantOutputBinding.authority.isAuthorityActive,
       recordFailure(operation, event, error) {
@@ -434,7 +443,6 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
         });
       },
     });
-  activityVerbosityBinding.bind(activityVerbosityRuntime);
   const activityRuntime = Activity.createTelegramActivityBridgeRuntime({
     generation: deps.generation,
     observeEvent(event) {
@@ -450,9 +458,30 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     },
   });
   return {
-    activityRuntime,
+    activityRuntime: {
+      ...activityRuntime,
+      onSessionStart() {
+        publication.reset();
+        activityRuntime.onSessionStart?.();
+      },
+      onSessionShutdown() {
+        publication.reset();
+        activityRuntime.onSessionShutdown();
+      },
+    },
     activityVerbosityRuntime,
     assistantOutputRuntime: assistantOutputBinding.runtime,
+    publicationRuntime: {
+      enqueue: publication.enqueue,
+      reserve: publication.reserve,
+      capture() {
+        const authority = assistantOutputBinding.authority.captureAuthority();
+        return {
+          target: authority.target ? { ...authority.target } : undefined,
+          isCurrent: () => assistantOutputBinding.authority.isAuthorityActive(authority),
+        };
+      },
+    },
   };
 }
 
@@ -680,6 +709,7 @@ export function registerTelegramCommandsAndTools({
 
 interface TelegramLifecycleBindingDeps {
   pi: Pi.ExtensionAPI;
+  publicationRuntime: TelegramBridgePublicationRuntime;
   activityRuntime: Activity.TelegramActivityRuntime;
   activityVerbosityRuntime?: ActivityVerbosity.TelegramActivityVerbosityRuntime;
   assistantOutputRuntime: Pick<
@@ -770,6 +800,7 @@ interface TelegramLifecycleBindingDeps {
 
 export function registerTelegramLifecycleRuntimeHooks({
   pi,
+  publicationRuntime,
   activityRuntime,
   activityVerbosityRuntime,
   assistantOutputRuntime,
@@ -936,24 +967,19 @@ export function registerTelegramLifecycleRuntimeHooks({
       { replyToPrompt: false },
     );
   };
-  let activeTurnDeliveryTail = Promise.resolve();
-  const scheduleActiveTurnDelivery = (task: () => Promise<void>): void => {
-    const previous = activeTurnDeliveryTail;
-    activeTurnDeliveryTail = (async () => {
-      await previous;
-      await new Promise<void>((resolve) => {
-        const timer = setTimeout(resolve, 0);
-        timer.unref?.();
-      });
-      await task();
-    })().catch((error) => {
-      recordRuntimeEvent("delivery", error, {
-        phase: "agent-end-background-delivery",
-      });
-    });
+  let pendingFinalPublication: {
+    turn: Queue.PendingTelegramTurn;
+    reservation: Activity.TelegramActivityPublicationReservation;
+  } | undefined;
+  const cancelPendingFinalPublication = (): void => {
+    pendingFinalPublication?.reservation.cancel();
+    pendingFinalPublication = undefined;
   };
-  const waitForActiveTurnDelivery = async (): Promise<void> => {
-    await activeTurnDeliveryTail;
+  const recordPublicationFailure = (error: unknown): void => {
+    recordRuntimeEvent("delivery", error, { phase: "agent-end-background-delivery" });
+  };
+  const scheduleActiveTurnDelivery = (task: () => Promise<void>): void => {
+    void publicationRuntime.enqueue(task).catch(recordPublicationFailure);
   };
   const agentLifecycleHooks = Queue.createTelegramAgentLifecycleHooks<
     Queue.PendingTelegramTurn,
@@ -989,14 +1015,22 @@ export function registerTelegramLifecycleRuntimeHooks({
     isSessionActive: isSessionContextActive,
     isTurnTransportActive,
     waitForTypingIdle: typing.waitForIdle,
-    async waitForActivityIdle() {
-      await activityVerbosityRuntime?.waitForIdle();
-      await assistantOutputRuntime.waitForIdle();
-    },
     dispatchNextQueuedTelegramTurn,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
     scheduleActiveTurnDelivery,
+    reserveActiveTurnDelivery() {
+      const pending = pendingFinalPublication;
+      pendingFinalPublication = undefined;
+      const matches = pending?.turn === activeTurnRuntime.get();
+      if (!matches) pending?.reservation.cancel();
+      const reservation = matches && pending ? pending.reservation : publicationRuntime.reserve();
+      return {
+        schedule: (task) => { void reservation.publish(task).catch(recordPublicationFailure); },
+        cancel: reservation.cancel,
+      };
+    },
+    preparePreviewClear: previewRuntime.prepareClear,
     clearPreview: previewRuntime.clear,
     setPreviewPendingText: previewRuntime.setPendingText,
     finalizeMarkdownPreview,
@@ -1038,25 +1072,24 @@ export function registerTelegramLifecycleRuntimeHooks({
   };
   let observedAutomaticCompaction = false;
   let agentWorkActive = false;
-  let terminalAssistantMessagePendingDelivery = false;
-  const deferredAutomaticCompactionNotices: string[] = [];
-  const sendCompactionNotice = async (text: string): Promise<void> => {
+  const prepareCompactionNotice = (text: string, ctx: Pi.ExtensionContext): (() => Promise<void>) => {
+    const authority = publicationRuntime.capture();
     const turn = activeTurnRuntime.get();
-    const target = turn?.target ?? proactivePushTargetGetter?.();
-    if (!target) return;
-    try {
-      await sendMarkdownReply(target.chatId, turn?.replyToMessageId, text, {
-        target,
-      });
-    } catch (error) {
-      recordRuntimeEvent("delivery", error, {
-        phase: "compaction-notice",
-      });
-    }
+    const selectedTarget = turn?.target ?? authority.target;
+    const target = selectedTarget ? { ...selectedTarget } : undefined;
+    const replyToMessageId = turn?.replyToMessageId;
+    return async () => {
+      if (!target || !isSessionContextActive(ctx) || !authority.isCurrent()) return;
+      if (turn && isTurnTransportActive?.(turn) === false) return;
+      try {
+        await sendMarkdownReply(target.chatId, replyToMessageId, text, { target });
+      } catch (error) {
+        recordRuntimeEvent("delivery", error, { phase: "compaction-notice" });
+      }
+    };
   };
-  const flushDeferredAutomaticCompactionNotices = async (): Promise<void> => {
-    const notices = deferredAutomaticCompactionNotices.splice(0);
-    for (const notice of notices) await sendCompactionNotice(notice);
+  const sendCompactionNotice = (text: string, ctx: Pi.ExtensionContext): void => {
+    scheduleActiveTurnDelivery(prepareCompactionNotice(text, ctx));
   };
   const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
     isContextActive: isSessionContextActive,
@@ -1070,7 +1103,6 @@ export function registerTelegramLifecycleRuntimeHooks({
     recordRuntimeEvent,
     onCompactionAbandoned: () => {
       observedAutomaticCompaction = false;
-      deferredAutomaticCompactionNotices.length = 0;
       activityRuntime.onCompactionAbandoned();
     },
   });
@@ -1091,6 +1123,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.recordInputSource(event.source ?? "unknown");
     },
     async onSessionStart(event, ctx) {
+      cancelPendingFinalPublication();
       previewRuntime.invalidate();
       assistantOutputRuntime.start();
       activityRuntime.onSessionStart?.();
@@ -1106,9 +1139,8 @@ export function registerTelegramLifecycleRuntimeHooks({
       assistantOutputRuntime.stop();
       observedAutomaticCompaction = false;
       agentWorkActive = false;
-      terminalAssistantMessagePendingDelivery = false;
+      cancelPendingFinalPublication();
       uiPromptActive = false;
-      deferredAutomaticCompactionNotices.length = 0;
       compactionObserver.onSessionShutdown();
       if (event.reason === "quit" && disconnectOnQuit) {
         try {
@@ -1129,19 +1161,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       if (shouldNotify) observedAutomaticCompaction = true;
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
-      if (shouldNotify) {
-        if (terminalAssistantMessagePendingDelivery) {
-          deferredAutomaticCompactionNotices.push(
-            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
-          );
-        } else {
-          await waitForActiveTurnDelivery();
-          if (!isSessionContextActive(ctx)) return;
-          await sendCompactionNotice(
-            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
-          );
-        }
-      }
+      if (shouldNotify) sendCompactionNotice(Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN, ctx);
     },
     async onSessionCompact(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1149,38 +1169,23 @@ export function registerTelegramLifecycleRuntimeHooks({
       compactionObserver.onSessionCompact(event, ctx);
       if (observedAutomaticCompaction) {
         observedAutomaticCompaction = false;
-        if (deferredAutomaticCompactionNotices.length > 0) {
-          deferredAutomaticCompactionNotices.push(
-            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
-          );
-        } else {
-          await sendCompactionNotice(
-            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
-          );
-        }
+        sendCompactionNotice(Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN, ctx);
       }
     },
     async onSessionCompactFailed(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       const shouldNotify = observedAutomaticCompaction;
-      const deferredNotices = deferredAutomaticCompactionNotices.splice(0);
-      const shouldDefer =
-        deferredNotices.length > 0 || terminalAssistantMessagePendingDelivery;
       compactionObserver.onSessionCompactFailed(event, ctx);
       if (!shouldNotify) return;
       const notice = event.aborted
         ? "**⚠️ Compaction cancelled.**"
         : "**⚠️ Compaction failed.**";
-      if (shouldDefer) {
-        deferredAutomaticCompactionNotices.push(...deferredNotices, notice);
-      } else {
-        await sendCompactionNotice(notice);
-      }
+      sendCompactionNotice(notice, ctx);
     },
     async onAgentStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       agentWorkActive = true;
-      terminalAssistantMessagePendingDelivery = false;
+      cancelPendingFinalPublication();
       await agentStartWithDedupReset(event, ctx);
       activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
       startAgentActivityTypingLoop(ctx);
@@ -1230,11 +1235,13 @@ export function registerTelegramLifecycleRuntimeHooks({
       if (event.message.role === "assistant") {
         activityRuntime.onAssistantMessageEnd(event.message.stopReason);
       }
-      terminalAssistantMessagePendingDelivery =
-        event.message.role === "assistant" &&
-        event.message.stopReason !== "toolUse" &&
-        event.message.stopReason !== "error" &&
-        event.message.stopReason !== "aborted";
+      if (event.message.role !== "assistant" || event.message.stopReason === "toolUse" || event.message.stopReason === "aborted") return;
+      const turn = activeTurnRuntime.get();
+      if (!turn || turn.guestQueryId || pendingFinalPublication?.turn === turn) return;
+      cancelPendingFinalPublication();
+      const assistant = Replies.extractLatestAssistantMessageText([event.message]);
+      if (!assistant.text && assistant.stopReason !== "error" && turn.queuedAttachments.length === 0) return;
+      pendingFinalPublication = { turn, reservation: publicationRuntime.reserve() };
     },
     onUiPromptStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1254,18 +1261,22 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      if (pendingFinalPublication && pendingFinalPublication.turn !== activeTurnRuntime.get()) {
+        cancelPendingFinalPublication();
+        return;
+      }
       activityRuntime.onAgentEnd();
       await agentLifecycleHooks.onAgentEnd(event, ctx);
     },
     async onAgentSettled(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
-      await agentLifecycleHooks.onAgentSettled(event, ctx);
-      if (deferredAutomaticCompactionNotices.length > 0) {
-        await waitForActiveTurnDelivery();
-        if (!isSessionContextActive(ctx)) return;
-        await flushDeferredAutomaticCompactionNotices();
+      const pending = pendingFinalPublication;
+      try {
+        await agentLifecycleHooks.onAgentSettled(event, ctx);
+      } finally {
+        if (pendingFinalPublication === pending) cancelPendingFinalPublication();
       }
-      terminalAssistantMessagePendingDelivery = false;
+      if (!isSessionContextActive(ctx)) return;
       agentWorkActive = false;
       activityRuntime.onAgentSettled();
       modelContextAvailabilityRuntime.reconcile();

package/node_modules/@llblab/pi-telegram/lib/lifecycle.ts

@@ -450,8 +450,10 @@ export function createTelegramCompactionObserverRuntime<TContext>(
   const setTimer = deps.setTimer ?? setTimeout;
   const clearTimer = deps.clearTimer ?? clearTimeout;
   let fallbackTimer: TelegramLifecycleTimer | undefined;
+  let observationGeneration = 0;
   let typingStartedByObserver = false;
   const clearFallbackTimer = (): void => {
+    observationGeneration += 1;
     if (!fallbackTimer) return;
     clearTimer(fallbackTimer);
     fallbackTimer = undefined;
@@ -470,7 +472,10 @@ export function createTelegramCompactionObserverRuntime<TContext>(
         !!deps.startTypingLoop && typingStartResult !== false;
       deps.updateStatus(ctx);
       clearFallbackTimer();
+      const admittedGeneration = observationGeneration;
       fallbackTimer = setTimer(() => {
+        if (observationGeneration !== admittedGeneration) return;
+        observationGeneration += 1;
         fallbackTimer = undefined;
         if (deps.isContextActive && !deps.isContextActive(ctx)) return;
         deps.setCompactionInProgress(false);
@@ -487,8 +492,8 @@ export function createTelegramCompactionObserverRuntime<TContext>(
       unrefTelegramLifecycleTimer(fallbackTimer);
     },
     onSessionCompact: (_event, ctx) => {
-      clearFallbackTimer();
       if (deps.isContextActive && !deps.isContextActive(ctx)) return;
+      clearFallbackTimer();
       deps.setCompactionInProgress(false);
       if (typingStartedByObserver) deps.stopTypingLoop?.();
       typingStartedByObserver = false;
@@ -496,8 +501,8 @@ export function createTelegramCompactionObserverRuntime<TContext>(
       requestDispatch();
     },
     onSessionCompactFailed: (_event, ctx) => {
-      clearFallbackTimer();
       if (deps.isContextActive && !deps.isContextActive(ctx)) return;
+      clearFallbackTimer();
       deps.setCompactionInProgress(false);
       if (typingStartedByObserver) deps.stopTypingLoop?.();
       typingStartedByObserver = false;

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

@@ -219,8 +219,9 @@ export function createTelegramRichOutboundAttachmentSender(
   return async (
     turn: TelegramQueuedOutboundAttachmentTurnView,
     markdown: string,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: unknown; isDeliveryActive?: () => boolean },
   ): Promise<boolean> => {
+    if (options?.isDeliveryActive?.() === false) return false;
     const plan = planTelegramRichOutboundAttachment({
       turn,
       markdown,
@@ -246,11 +247,13 @@ export function createTelegramRichOutboundAttachmentSender(
           new Error("Successful Rich media upload omitted message_id."),
         );
       }
-      deps.recordOwnership?.({
-        chatId: turn.chatId,
-        messageId,
-        target: turn.target,
-      });
+      if (options?.isDeliveryActive?.() !== false) {
+        deps.recordOwnership?.({
+          chatId: turn.chatId,
+          messageId,
+          target: turn.target,
+        });
+      }
       return true;
     } catch (error) {
       if (isTelegramRichAttachmentCommitUnknownError(error)) throw error;
@@ -580,6 +583,7 @@ export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
   ) => void;
   statPath?: (path: string) => Promise<{ size: number }>;
   maxAttachmentSizeBytes?: number;
+  isDeliveryActive?: () => boolean;
 }
 
 export async function queueTelegramOutboundAttachments(options: {
@@ -925,9 +929,13 @@ export async function sendTelegramOutboundFiles(options: {
 export function createTelegramQueuedOutboundAttachmentSender(
   deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ) {
-  return async (turn: TelegramQueuedOutboundAttachmentTurnView): Promise<void> => {
+  return async (
+    turn: TelegramQueuedOutboundAttachmentTurnView,
+    options?: { isDeliveryActive?: () => boolean },
+  ): Promise<void> => {
     await sendQueuedTelegramOutboundAttachments(turn, {
       ...deps,
+      isDeliveryActive: () => deps.isDeliveryActive?.() !== false && options?.isDeliveryActive?.() !== false,
       maxAttachmentSizeBytes:
         deps.maxAttachmentSizeBytes ?? TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES,
     });
@@ -939,9 +947,11 @@ export async function sendQueuedTelegramOutboundAttachments(
   deps: TelegramQueuedOutboundAttachmentDeliveryDeps,
 ): Promise<void> {
   for (const attachment of turn.queuedAttachments) {
+    if (deps.isDeliveryActive?.() === false) return;
     try {
       if (deps.maxAttachmentSizeBytes !== undefined) {
         const stats = await (deps.statPath ?? stat)(attachment.path);
+        if (deps.isDeliveryActive?.() === false) return;
         if (stats.size > deps.maxAttachmentSizeBytes) {
           throw new Error(
             formatTelegramOutboundAttachmentSizeLimitError(
@@ -971,6 +981,7 @@ export async function sendQueuedTelegramOutboundAttachments(
         attachment.fileName,
       );
     } catch (error) {
+      if (deps.isDeliveryActive?.() === false) return;
       const message = error instanceof Error ? error.message : String(error);
       deps.recordRuntimeEvent?.("attachment", error, {
         fileName: attachment.fileName,

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

@@ -14,6 +14,7 @@ import {
   type TelegramTarget,
 } from "./target.ts";
 import { getTelegramVoiceSynthesisProviders } from "./voice.ts";
+import { isTelegramApiCommitUnknownError } from "./telegram-api.ts";
 
 export interface TelegramVoiceReplyTurnView {
   chatId: number;
@@ -47,6 +48,7 @@ export interface TelegramVoiceReplySenderDeps {
   ) => Promise<unknown>;
   sendChatAction?: (chatId: number, action: string) => Promise<unknown>;
   sendRecordVoiceAction?: (chatId: number) => Promise<unknown>;
+  isDeliveryActive?: () => boolean;
   getHandlers?: () => unknown[] | undefined;
   cwd?: string;
   tempDir?: string;
@@ -123,9 +125,12 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
       replyMarkup?: unknown;
     },
   ): Promise<void> => {
+    if (deps.isDeliveryActive?.() === false) return;
     const voiceFilePath = await ensureTelegramVoiceFileFormat(filePath);
     assertTelegramInlineKeyboardCallbackData(options?.replyMarkup);
+    if (deps.isDeliveryActive?.() === false) return;
     await sendVoiceChatAction(deps, turn.chatId);
+    if (deps.isDeliveryActive?.() === false) return;
     const replyParameters = buildVoiceReplyParameters(
       turn.chatId,
       options?.replyToPrompt,
@@ -171,6 +176,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
   ): Promise<void> => {
     for (const handler of ports.findVoiceHandlers?.(deps.getHandlers?.()) ??
       []) {
+      if (deps.isDeliveryActive?.() === false) return;
       try {
         const filePath = await ports.generateVoiceFile?.(text, {
           lang: options?.lang,
@@ -187,6 +193,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
         });
         return;
       } catch (error) {
+        if (isTelegramApiCommitUnknownError(error)) throw error;
         deps.recordRuntimeEvent?.("voice", error, {
           phase: "template-handler-send",
         });
@@ -194,6 +201,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
     }
 
     for (const handler of ports.getProgrammaticVoiceHandlers?.() ?? []) {
+      if (deps.isDeliveryActive?.() === false) return;
       try {
         const filePath = await handler(text, {
           lang: options?.lang,
@@ -206,6 +214,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
         });
         return;
       } catch (error) {
+        if (isTelegramApiCommitUnknownError(error)) throw error;
         deps.recordRuntimeEvent?.("voice", error, {
           phase: "programmatic-handler-send",
         });
@@ -215,6 +224,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
     const providers = getTelegramVoiceSynthesisProviders();
 
     for (const provider of providers) {
+      if (deps.isDeliveryActive?.() === false) return;
       let voiceFilePath: string | undefined;
       let originalFilePath: string | undefined;
 
@@ -252,6 +262,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
         });
         return;
       } catch (error) {
+        if (isTelegramApiCommitUnknownError(error)) throw error;
         deps.recordRuntimeEvent?.("voice", error, { phase: "send" });
       } finally {
         if (voiceFilePath && voiceFilePath !== originalFilePath) {

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 { isTelegramApiCommitUnknownError } from "./telegram-api.ts";
 import type {
   TelegramEditMessageTextBody,
   TelegramSendMessageBody,
@@ -137,6 +138,7 @@ export interface TelegramVoiceReplySenderDeps {
   ) => Promise<unknown>;
   sendChatAction?: (chatId: number, action: string) => Promise<unknown>;
   sendRecordVoiceAction?: (chatId: number) => Promise<unknown>;
+  isDeliveryActive?: () => boolean;
   getHandlers?: () => TelegramOutboundHandlerConfig[] | undefined;
   cwd?: string;
   tempDir?: string;
@@ -877,15 +879,17 @@ export function createTelegramOutboundReplyPlanner(
 export function createTelegramOutboundReplyArtifactSender(
   deps: TelegramVoiceReplySenderDeps,
 ) {
-  const sendVoiceReply = createTelegramVoiceReplySender(deps);
   return async (
     turn: TelegramVoiceReplyTurnView,
     plan: Pick<
       TelegramOutboundReplyPlan,
       "voiceText" | "voiceReplies" | "lang" | "rate" | "replyMarkup"
     >,
-    options?: { replyToPrompt?: boolean },
+    options?: { replyToPrompt?: boolean; isDeliveryActive?: () => boolean },
   ): Promise<void> => {
+    const isDeliveryActive = () =>
+      deps.isDeliveryActive?.() !== false && options?.isDeliveryActive?.() !== false;
+    const sendVoiceReply = createTelegramVoiceReplySender({ ...deps, isDeliveryActive });
     // Normalize voice replies: either use explicit voiceReplies array or fall back to voiceText
     const voiceReplies = plan.voiceReplies?.length
       ? plan.voiceReplies
@@ -896,6 +900,7 @@ export function createTelegramOutboundReplyArtifactSender(
     let anyDelivered = false;
 
     for (const reply of voiceReplies) {
+      if (!isDeliveryActive()) return;
       try {
         await sendVoiceReply(turn, reply.text, {
           lang: reply.lang ?? plan.lang,
@@ -905,11 +910,13 @@ export function createTelegramOutboundReplyArtifactSender(
           replyMarkup: !anyDelivered ? plan.replyMarkup : undefined,
         });
         anyDelivered = true;
-      } catch {
+      } catch (error) {
+        if (isTelegramApiCommitUnknownError(error)) throw error;
         // sendVoiceReply already recorded the error; continue to next reply
       }
     }
 
+    if (!isDeliveryActive()) return;
     if (!anyDelivered) {
       throw new Error(
         "Failed to send voice reply: every voice synthesis provider failed.",

package/node_modules/@llblab/pi-telegram/lib/preview.ts

@@ -140,6 +140,10 @@ export interface TelegramPreviewControllerDeps {
 }
 
 export interface TelegramPreviewController {
+  prepareClear: (
+    chatId: number,
+    options?: { target?: TelegramTarget; isDeliveryActive?: () => boolean },
+  ) => () => Promise<void>;
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
   setPendingText: (text: string) => void;
@@ -322,6 +326,17 @@ export function createTelegramPreviewController(
       generation += 1;
       state = undefined;
     },
+    prepareClear: (chatId, options) => {
+      const admittedState = state;
+      const runtime = getRuntimeDeps();
+      return async () => {
+        if (state !== admittedState) return;
+        await clearTelegramPreview(chatId, runtime, {
+          ...options,
+          isDeliveryActive: () => runtime.canSend?.() !== false && options?.isDeliveryActive?.() !== false,
+        });
+      };
+    },
     clear: (chatId, options) =>
       clearTelegramPreview(chatId, getRuntimeDeps(), options),
     flush: (chatId, options) =>
@@ -454,17 +469,18 @@ export function shouldUseTelegramDraftPreview(_options: {
 export async function clearTelegramPreview(
   chatId: number,
   deps: TelegramPreviewRuntimeDeps,
-  options: { awaitFlush?: boolean; target?: TelegramTarget } = {},
+  options: { awaitFlush?: boolean; target?: TelegramTarget; isDeliveryActive?: () => boolean } = {},
 ): Promise<void> {
   const state = deps.getState();
-  if (!state) return;
+  if (!state || options.isDeliveryActive?.() === false) return;
   if (state.flushPromise && options.awaitFlush !== false) {
     state.flushRequested = false;
     await state.flushPromise.catch(() => {});
     if (deps.getState() !== state) return;
   }
+  if (options.isDeliveryActive?.() === false) return;
   deps.setState(undefined);
-  if (state.mode === "draft" && state.draftId !== undefined) {
+  if (state.mode === "draft" && state.draftId !== undefined && deps.canSend?.() !== false) {
     try {
       await deps.sendDraft(chatId, state.draftId, undefined, {
         ...getTelegramTargetThreadParams(options.target ?? { chatId }),