@llblab/pi-kit 0.5.1 → 0.6.0

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

@@ -353,6 +353,8 @@ export function createTelegramAssistantOutputBindingRuntime<
     typeof OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>
   >[0];
   waitForActivityIdle?: () => Promise<void>;
+  prepareTelegramPreview?: () => Activity.TelegramAssistantOutputPreparation | undefined;
+  enqueue?: Activity.TelegramActivityPublicationRuntime["enqueue"];
   recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }): TelegramAssistantOutputBindingRuntime<TTransportStamp> {
   const authority = Routing.createTelegramAssistantOutputAuthorityRuntime(
@@ -364,6 +366,8 @@ export function createTelegramAssistantOutputBindingRuntime<
     );
   const runtime = Activity.createTelegramAssistantOutputRuntime({
     ...authority,
+    enqueue: deps.enqueue,
+    prepareSend: (event) => event.source === "telegram" ? deps.prepareTelegramPreview?.() : undefined,
     async send(event, authority, isAuthorityActive) {
       await deps.waitForActivityIdle?.();
       if (!isAuthorityActive()) return;
@@ -390,7 +394,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 +414,7 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     Parameters<
       typeof createTelegramAssistantOutputBindingRuntime<TTransportStamp>
     >[0],
-    "waitForActivityIdle"
+    "waitForActivityIdle" | "enqueue"
   >;
   activityVerbosity: Omit<
     Parameters<
@@ -411,19 +422,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 +445,6 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
         });
       },
     });
-  activityVerbosityBinding.bind(activityVerbosityRuntime);
   const activityRuntime = Activity.createTelegramActivityBridgeRuntime({
     generation: deps.generation,
     observeEvent(event) {
@@ -450,9 +460,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 +711,7 @@ export function registerTelegramCommandsAndTools({
 
 interface TelegramLifecycleBindingDeps {
   pi: Pi.ExtensionAPI;
+  publicationRuntime: TelegramBridgePublicationRuntime;
   activityRuntime: Activity.TelegramActivityRuntime;
   activityVerbosityRuntime?: ActivityVerbosity.TelegramActivityVerbosityRuntime;
   assistantOutputRuntime: Pick<
@@ -748,6 +780,7 @@ interface TelegramLifecycleBindingDeps {
       Keyboard.TelegramInlineKeyboardMarkup
     >["sendGuestReply"]
   >;
+  preparePreviewDelivery?: Queue.TelegramAgentEndRuntimeDeps<Queue.PendingTelegramTurn>["preparePreviewDelivery"];
   finalizeMarkdownPreview: Queue.TelegramAgentEndHookRuntimeDeps<
     Queue.PendingTelegramTurn,
     Pi.ExtensionContext,
@@ -770,6 +803,7 @@ interface TelegramLifecycleBindingDeps {
 
 export function registerTelegramLifecycleRuntimeHooks({
   pi,
+  publicationRuntime,
   activityRuntime,
   activityVerbosityRuntime,
   assistantOutputRuntime,
@@ -798,6 +832,7 @@ export function registerTelegramLifecycleRuntimeHooks({
   answerGuestQuery,
   deleteMessage,
   sendGuestReply,
+  preparePreviewDelivery,
   finalizeMarkdownPreview,
   proactivePushTargetGetter,
   getAssistantRenderingMode,
@@ -936,24 +971,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 +1019,23 @@ 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,
+      };
+    },
+    preparePreviewDelivery,
+    preparePreviewClear: previewRuntime.prepareClear,
     clearPreview: previewRuntime.clear,
     setPreviewPendingText: previewRuntime.setPendingText,
     finalizeMarkdownPreview,
@@ -1018,6 +1057,7 @@ export function registerTelegramLifecycleRuntimeHooks({
   Lifecycle.setResetTransportReplyDedup(Replies.resetTransportReplyDedup);
   const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
     agentLifecycleHooks.onAgentStart,
+    scheduleActiveTurnDelivery,
   );
   let uiPromptActive = false;
   const startAgentActivityTypingLoop = (ctx: Pi.ExtensionContext): boolean => {
@@ -1038,25 +1078,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 +1109,6 @@ export function registerTelegramLifecycleRuntimeHooks({
     recordRuntimeEvent,
     onCompactionAbandoned: () => {
       observedAutomaticCompaction = false;
-      deferredAutomaticCompactionNotices.length = 0;
       activityRuntime.onCompactionAbandoned();
     },
   });
@@ -1091,6 +1129,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.recordInputSource(event.source ?? "unknown");
     },
     async onSessionStart(event, ctx) {
+      cancelPendingFinalPublication();
       previewRuntime.invalidate();
       assistantOutputRuntime.start();
       activityRuntime.onSessionStart?.();
@@ -1106,9 +1145,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 +1167,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,40 +1175,26 @@ 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);
+      const turn = activeTurnRuntime.get();
+      activityRuntime.onAgentStart(turn?.target, turn?.replyToMessageId);
       startAgentActivityTypingLoop(ctx);
     },
     async onToolExecutionStart(event, ctx) {
@@ -1228,13 +1240,16 @@ export function registerTelegramLifecycleRuntimeHooks({
     onMessageEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       if (event.message.role === "assistant") {
+        previewRuntime.seal();
         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 +1269,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/config.ts

@@ -744,7 +744,7 @@ export function createTelegramDraftPreviewsChecker(
       config.assistant?.draftPreviews ??
       config.draftPreviews ??
       config.richDraftPreviews ??
-      false
+      true
     );
   };
 }

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

@@ -10,7 +10,7 @@ import {
   type TelegramInlineKeyboardMarkup,
 } from "./keyboard.ts";
 import {
-  buildTelegramReplyParameters,
+  withTelegramReplyParameters,
   renderTelegramMessage,
 } from "./replies.ts";
 import {
@@ -724,23 +724,23 @@ export function createTelegramBridgeDeliveryRuntime(
     },
     async sendChunk(target, chunk, options) {
       assertTransportActive();
-      const replyParameters = buildTelegramReplyParameters(
-        target.chatId,
-        options.replyToMessageId,
-        target,
-      );
-      const body = {
-        chat_id: target.chatId,
-        text: chunk.text,
-        ...(chunk.parseMode === "html" ? { parse_mode: "HTML" as const } : {}),
-        ...getTelegramTargetThreadParams(target),
-        ...(replyParameters ? { reply_parameters: replyParameters } : {}),
-        ...(options.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
-      };
-      const sent = await deps.api.sendMessage(
-        target.threadId === undefined
-          ? markTelegramBusAggregateDelivery(body)
-          : body,
+      const sent = await withTelegramReplyParameters(
+        target.chatId, options.replyToMessageId, target,
+        (replyParameters) => {
+          const body = {
+            chat_id: target.chatId,
+            text: chunk.text,
+            ...(chunk.parseMode === "html" ? { parse_mode: "HTML" as const } : {}),
+            ...getTelegramTargetThreadParams(target),
+            ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+            ...(options.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
+          };
+          return deps.api.sendMessage(
+            target.threadId === undefined
+              ? markTelegramBusAggregateDelivery(body)
+              : body,
+          );
+        },
       );
       assertTransportActive();
       deps.recordOwnership({

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

@@ -37,9 +37,15 @@ export function setResetTransportReplyDedup(fn: () => void): void {
 
 export function createAgentStartDedupHook(
   inner: (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>,
+  schedulePublication?: (task: () => Promise<void>) => void,
 ): (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void> {
   return async (event, ctx) => {
-    if (resetTransportReplyDedupFn) resetTransportReplyDedupFn();
+    const reset = resetTransportReplyDedupFn;
+    if (reset) {
+      // A new turn must not erase the anchor of a final still ahead in the FIFO.
+      if (schedulePublication) schedulePublication(async () => { reset(); });
+      else reset();
+    }
     return inner(event, ctx);
   };
 }
@@ -450,8 +456,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 +478,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 +498,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 +507,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/menu-settings.ts

@@ -184,8 +184,8 @@ export function buildDraftPreviewsSettingsText(enabled: boolean): string {
     "",
     "Show live answer drafts while the model is answering.",
     "",
-    "<code>-</code> <code>on</code>: stream safe Telegram Rich Draft frames before the final answer.",
-    "<code>-</code> <code>off</code> (default): show native active status, then send one final answer.",
+    "<code>-</code> <code>on</code> (default): stream safe Telegram Rich Draft frames before the final answer.",
+    "<code>-</code> <code>off</code>: show native active status, then send one final answer.",
   ].join("\n");
 }
 

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
@@ -219,8 +211,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,
@@ -229,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" &&
@@ -246,11 +242,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 +578,7 @@ export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
   ) => void;
   statPath?: (path: string) => Promise<{ size: number }>;
   maxAttachmentSizeBytes?: number;
+  isDeliveryActive?: () => boolean;
 }
 
 export async function queueTelegramOutboundAttachments(options: {
@@ -925,9 +924,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 +942,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(
@@ -954,23 +959,22 @@ 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;
       const message = error instanceof Error ? error.message : String(error);
       deps.recordRuntimeEvent?.("attachment", error, {
         fileName: attachment.fileName,