@llblab/pi-telegram 0.51.0 → 0.51.2

package/lib/model.ts

@@ -374,7 +374,6 @@ export interface PendingModelSwitchStore<TSelection> {
 
 export interface TelegramInFlightModelSwitchState {
   isIdle: boolean;
-  hasActiveTelegramTurn: boolean;
   hasAbortHandler: boolean;
 }
 
@@ -394,21 +393,21 @@ export function createPendingModelSwitchStore<
   };
 }
 
-export function canRestartTelegramTurnForModelSwitch(
+export function canRestartAgentRunForTelegramModelSwitch(
   state: TelegramInFlightModelSwitchState,
 ): boolean {
-  return !state.isIdle && state.hasActiveTelegramTurn && state.hasAbortHandler;
+  return !state.isIdle && state.hasAbortHandler;
 }
 
 export function shouldTriggerPendingTelegramModelSwitchAbort(state: {
   hasPendingModelSwitch: boolean;
-  hasActiveTelegramTurn: boolean;
+  hasContinuationTurn: boolean;
   hasAbortHandler: boolean;
   activeToolExecutions: number;
 }): boolean {
   return (
     state.hasPendingModelSwitch &&
-    state.hasActiveTelegramTurn &&
+    state.hasContinuationTurn &&
     state.hasAbortHandler &&
     state.activeToolExecutions === 0
   );
@@ -458,13 +457,18 @@ export function buildTelegramModelSwitchContinuationText<
   const thinkingSuffix = thinkingLevel
     ? ` Keep the selected thinking level (${thinkingLevel}) if it still applies.`
     : "";
-  return `${telegramPrefix} Continue the interrupted previous Telegram request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
+  return `${telegramPrefix} Continue the interrupted previous request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
 }
 
+export type TelegramModelSwitchContinuationSource = Pick<
+  PendingTelegramTurn,
+  "chatId" | "replyToMessageId" | "target"
+>;
+
 export function buildTelegramModelSwitchContinuationTurn<
   TModel extends MenuModel,
 >(options: {
-  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+  turn: TelegramModelSwitchContinuationSource;
   selection: ScopedTelegramModel<TModel>;
   telegramPrefix?: string;
   queueOrder: number;
@@ -494,7 +498,7 @@ export function buildTelegramModelSwitchContinuationTurn<
         ),
       },
     ],
-    historyText: `Continue interrupted Telegram request on ${modelLabel}`,
+    historyText: `Continue interrupted request on ${modelLabel}`,
     statusSummary: `↻ ${statusLabel || "continue"}`,
   };
 }
@@ -506,7 +510,7 @@ export function createTelegramModelSwitchContinuationTurnBuilder<
   allocateItemOrder: () => number;
   allocateControlOrder: () => number;
 }): (options: {
-  turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+  turn: TelegramModelSwitchContinuationSource;
   selection: ScopedTelegramModel<TModel>;
 }) => PendingTelegramTurn {
   return (options) =>
@@ -523,11 +527,15 @@ export function createTelegramModelSwitchContinuationQueue<
   TSelection extends ScopedTelegramModel,
 >(deps: {
   createContinuationTurn: (options: {
-    turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+    turn: TelegramModelSwitchContinuationSource;
     selection: TSelection;
   }) => PendingTelegramTurn;
   appendQueuedItem: (item: PendingTelegramTurn, ctx: TContext) => void;
-}): (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void {
+}): (
+  turn: TelegramModelSwitchContinuationSource,
+  selection: TSelection,
+  ctx: TContext,
+) => void {
   return (turn, selection, ctx) => {
     deps.appendQueuedItem(
       deps.createContinuationTurn({ turn, selection }),
@@ -544,7 +552,11 @@ export function createTelegramModelSwitchContinuationQueueRuntime<
   allocateItemOrder: () => number;
   allocateControlOrder: () => number;
   appendQueuedItem: (item: PendingTelegramTurn, ctx: TContext) => void;
-}): (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void {
+}): (
+  turn: TelegramModelSwitchContinuationSource,
+  selection: TSelection,
+  ctx: TContext,
+) => void {
   return createTelegramModelSwitchContinuationQueue<TContext, TSelection>({
     createContinuationTurn: createTelegramModelSwitchContinuationTurnBuilder({
       telegramPrefix: deps.telegramPrefix,
@@ -564,7 +576,7 @@ export interface TelegramModelSwitchControllerDeps<TContext, TSelection> {
   hasAbortHandler: () => boolean;
   getActiveToolExecutions: () => number;
   queueContinuation: (
-    turn: PendingTelegramTurn,
+    turn: TelegramModelSwitchContinuationSource,
     selection: TSelection,
     ctx: TContext,
   ) => void;
@@ -573,15 +585,23 @@ export interface TelegramModelSwitchControllerDeps<TContext, TSelection> {
 
 export interface TelegramModelSwitchController<TContext, TSelection> {
   canOfferInFlightSwitch: (ctx: TContext) => boolean;
-  stagePendingSwitch: (selection: TSelection, ctx: TContext) => void;
+  stagePendingSwitch: (
+    selection: TSelection,
+    ctx: TContext,
+    continuationTurn?: TelegramModelSwitchContinuationSource,
+  ) => void;
   clearPendingSwitch: () => void;
   queueContinuation: (
-    turn: PendingTelegramTurn,
+    turn: TelegramModelSwitchContinuationSource,
     selection: TSelection,
     ctx: TContext,
   ) => void;
   triggerPendingAbort: (ctx: TContext) => boolean;
-  restartInterruptedTurn: (selection: TSelection, ctx: TContext) => boolean;
+  restartInterruptedTurn: (
+    selection: TSelection,
+    ctx: TContext,
+    continuationTurn?: TelegramModelSwitchContinuationSource,
+  ) => boolean;
 }
 
 export interface TelegramModelSwitchControllerRuntimeDeps<
@@ -624,49 +644,62 @@ export function createTelegramModelSwitchControllerRuntime<
 export function createTelegramModelSwitchController<TContext, TSelection>(
   deps: TelegramModelSwitchControllerDeps<TContext, TSelection>,
 ): TelegramModelSwitchController<TContext, TSelection> {
+  let pendingContinuationTurn:
+    | TelegramModelSwitchContinuationSource
+    | undefined;
+  const triggerPendingAbort = (ctx: TContext): boolean => {
+    const turn = pendingContinuationTurn ?? deps.getActiveTurn();
+    if (
+      !shouldTriggerPendingTelegramModelSwitchAbort({
+        hasPendingModelSwitch: !!deps.getPendingModelSwitch(),
+        hasContinuationTurn: !!turn,
+        hasAbortHandler: deps.hasAbortHandler(),
+        activeToolExecutions: deps.getActiveToolExecutions(),
+      })
+    ) {
+      return false;
+    }
+    const selection = deps.getPendingModelSwitch();
+    const abort = deps.getAbortHandler();
+    if (!selection || !turn || !abort) return false;
+    pendingContinuationTurn = undefined;
+    deps.setPendingModelSwitch(undefined);
+    deps.queueContinuation(turn, selection, ctx);
+    abort();
+    return true;
+  };
   return {
     canOfferInFlightSwitch: (ctx) =>
-      canRestartTelegramTurnForModelSwitch({
+      canRestartAgentRunForTelegramModelSwitch({
         isIdle: deps.isIdle(ctx),
-        hasActiveTelegramTurn: !!deps.getActiveTurn(),
         hasAbortHandler: deps.hasAbortHandler(),
       }),
-    stagePendingSwitch: (selection, ctx) => {
+    stagePendingSwitch: (selection, ctx, continuationTurn) => {
+      pendingContinuationTurn = deps.getActiveTurn() ?? continuationTurn;
       deps.setPendingModelSwitch(selection);
-      deps.updateStatus(ctx);
+      try {
+        deps.updateStatus(ctx);
+      } finally {
+        triggerPendingAbort(ctx);
+      }
     },
     clearPendingSwitch: () => {
+      pendingContinuationTurn = undefined;
       deps.setPendingModelSwitch(undefined);
     },
     queueContinuation: deps.queueContinuation,
-    triggerPendingAbort: (ctx) => {
-      if (
-        !shouldTriggerPendingTelegramModelSwitchAbort({
-          hasPendingModelSwitch: !!deps.getPendingModelSwitch(),
-          hasActiveTelegramTurn: !!deps.getActiveTurn(),
-          hasAbortHandler: deps.hasAbortHandler(),
-          activeToolExecutions: deps.getActiveToolExecutions(),
-        })
-      ) {
-        return false;
-      }
-      const selection = deps.getPendingModelSwitch();
-      const turn = deps.getActiveTurn();
-      const abort = deps.getAbortHandler();
-      if (!selection || !turn || !abort) return false;
-      deps.setPendingModelSwitch(undefined);
-      deps.queueContinuation(turn, selection, ctx);
-      abort();
-      return true;
-    },
-    restartInterruptedTurn: (selection, ctx) =>
-      restartTelegramModelSwitchContinuation({
-        activeTurn: deps.getActiveTurn(),
+    triggerPendingAbort,
+    restartInterruptedTurn: (selection, ctx, continuationTurn) => {
+      const restarted = restartTelegramModelSwitchContinuation({
+        activeTurn: deps.getActiveTurn() ?? continuationTurn,
         abort: deps.getAbortHandler(),
         selection,
         queueContinuation: (turn, nextSelection) => {
           deps.queueContinuation(turn, nextSelection, ctx);
         },
-      }),
+      });
+      if (restarted) pendingContinuationTurn = undefined;
+      return restarted;
+    },
   };
 }

package/lib/queue.ts

@@ -126,6 +126,8 @@ export interface PendingTelegramTurn extends TelegramQueueItemBase {
   historyText: string;
   priorityEmoji?: string;
   reactionSuppressionEmoji?: string;
+  /** Emit the explicit aborted-turn notice when /next settles this active turn. */
+  announceNextAbortOnEnd?: boolean;
 
   /** Turn should preferably be delivered as voice (mirror mode + user sent voice) */
   voiceReplyPreferred?: boolean;
@@ -235,6 +237,8 @@ export interface TelegramActiveTurnStore<
   has: () => boolean;
   set: (turn: TTurn) => void;
   clear: () => void;
+  markNextAbortAnnouncement: () => boolean;
+  clearNextAbortAnnouncement: () => boolean;
   getChatId: () => number | undefined;
   getTarget: () => TelegramQueueTarget | undefined;
   getReplyToMessageId: () => number | undefined;
@@ -461,6 +465,16 @@ export function createTelegramActiveTurnStore<
     clear: () => {
       activeTurn = undefined;
     },
+    markNextAbortAnnouncement: () => {
+      if (!activeTurn) return false;
+      activeTurn.announceNextAbortOnEnd = true;
+      return true;
+    },
+    clearNextAbortAnnouncement: () => {
+      if (!activeTurn?.announceNextAbortOnEnd) return false;
+      delete activeTurn.announceNextAbortOnEnd;
+      return true;
+    },
     getChatId: () => activeTurn?.chatId,
     getTarget: () =>
       activeTurn?.target ? { ...activeTurn.target } : undefined,
@@ -1239,7 +1253,6 @@ export interface TelegramAgentStartHookRuntimeDeps<
 export type TelegramAgentStartHookEvent = unknown;
 
 export interface TelegramToolExecutionRuntimeDeps {
-  hasActiveTurn: () => boolean;
   getActiveToolExecutions: () => number;
   setActiveToolExecutions: (count: number) => void;
 }
@@ -1347,11 +1360,9 @@ export function createTelegramAgentStartHook<
 }
 
 export function getNextTelegramToolExecutionCount(options: {
-  hasActiveTurn: boolean;
   currentCount: number;
   event: "start" | "end";
 }): number {
-  if (!options.hasActiveTurn) return options.currentCount;
   if (options.event === "start") {
     return options.currentCount + 1;
   }
@@ -1363,7 +1374,6 @@ export function handleTelegramToolExecutionStartRuntime(
 ): void {
   deps.setActiveToolExecutions(
     getNextTelegramToolExecutionCount({
-      hasActiveTurn: deps.hasActiveTurn(),
       currentCount: deps.getActiveToolExecutions(),
       event: "start",
     }),
@@ -1373,15 +1383,13 @@ export function handleTelegramToolExecutionStartRuntime(
 export function handleTelegramToolExecutionEndRuntime(
   deps: TelegramToolExecutionEndRuntimeDeps,
 ): void {
-  const hasActiveTurn = deps.hasActiveTurn();
   deps.setActiveToolExecutions(
     getNextTelegramToolExecutionCount({
-      hasActiveTurn,
       currentCount: deps.getActiveToolExecutions(),
       event: "end",
     }),
   );
-  if (hasActiveTurn) deps.triggerPendingModelSwitchAbort();
+  deps.triggerPendingModelSwitchAbort();
 }
 
 export type TelegramAgentLifecycleHooksRuntimeDeps<
@@ -1471,7 +1479,6 @@ export function createTelegramToolExecutionHooks<TContext>(
       ctx: TContext,
     ): void => {
       handleTelegramToolExecutionEndRuntime({
-        hasActiveTurn: deps.hasActiveTurn,
         getActiveToolExecutions: deps.getActiveToolExecutions,
         setActiveToolExecutions: deps.setActiveToolExecutions,
         triggerPendingModelSwitchAbort: () => {
@@ -1488,6 +1495,7 @@ export interface TelegramAgentEndPlan {
   kind: "no-turn" | "aborted" | "error" | "text" | "attachments-only" | "empty";
   shouldClearPreview: boolean;
   shouldDispatchNext: boolean;
+  shouldSendAbortMessage: boolean;
   shouldSendErrorMessage: boolean;
   shouldSendAttachmentNotice: boolean;
 }
@@ -1680,6 +1688,7 @@ export function buildTelegramAgentEndPlan(options: {
   hasFinalText: boolean;
   hasQueuedAttachments: boolean;
   foldQueuedPromptsIntoHistory: boolean;
+  announceNextAbortOnEnd?: boolean;
 }): TelegramAgentEndPlan {
   const shouldDispatchNext = shouldDispatchAfterTelegramAgentEnd({
     hasTurn: options.hasTurn,
@@ -1691,6 +1700,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "no-turn",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1700,6 +1710,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "aborted",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: options.announceNextAbortOnEnd === true,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1709,6 +1720,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "error",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: true,
       shouldSendAttachmentNotice: false,
     };
@@ -1718,6 +1730,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "text",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1727,6 +1740,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "attachments-only",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: true,
     };
@@ -1735,6 +1749,7 @@ export function buildTelegramAgentEndPlan(options: {
     kind: "empty",
     shouldClearPreview: true,
     shouldDispatchNext,
+    shouldSendAbortMessage: false,
     shouldSendErrorMessage: false,
     shouldSendAttachmentNotice: false,
   };
@@ -1891,6 +1906,7 @@ export async function handleTelegramAgentEndRuntime<
     hasFinalText: !!finalText || hasOutboundArtifacts,
     hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
     foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
+    announceNextAbortOnEnd: turn?.announceNextAbortOnEnd === true,
   });
   if (!turn) {
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
@@ -2017,22 +2033,29 @@ export async function handleTelegramAgentEndRuntime<
       await clearTurnPreview();
       if (!isDeliveryActive()) return;
     }
-    if (endPlan.shouldSendErrorMessage) {
+    if (endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage) {
       const errorMessage = assistant.errorMessage ||
         "Telegram bridge: Pi failed while processing the request.";
-      const isOperationAborted = errorMessage.trim().replace(/\.$/, "") ===
-        "This operation was aborted";
-      await deps.sendTextReply(
-        turn.chatId,
-        turn.replyToMessageId,
-        isOperationAborted
-          ? "<b>⏹️ This operation was aborted.</b>"
-          : errorMessage,
-        {
-          target: turn.target,
-          ...(isOperationAborted ? { parseMode: "HTML" as const } : {}),
-        },
-      );
+      const isOperationAborted = endPlan.shouldSendAbortMessage ||
+        errorMessage.trim().replace(/\.$/, "") === "This operation was aborted";
+      try {
+        await deps.sendTextReply(
+          turn.chatId,
+          turn.replyToMessageId,
+          isOperationAborted
+            ? "<b>⏹️ This operation was aborted.</b>"
+            : errorMessage,
+          {
+            target: turn.target,
+            ...(isOperationAborted ? { parseMode: "HTML" as const } : {}),
+          },
+        );
+      } catch (error) {
+        if (!isOperationAborted) throw error;
+        deps.recordRuntimeEvent?.("dispatch", error, {
+          phase: "next-abort-announcement",
+        });
+      }
       if (!isDeliveryActive()) return;
       if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
       return;
@@ -2180,7 +2203,7 @@ export async function handleTelegramAgentEndRuntime<
   };
   if (
     deps.scheduleActiveTurnDelivery &&
-    (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)
+    (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)
   ) {
     deps.scheduleActiveTurnDelivery(deliverActiveTurn);
     return;
@@ -3092,6 +3115,9 @@ export interface TelegramQueueDispatchControllerDeps<
   ) => boolean;
   sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
   onPromptDispatchFailure: (ctx: TContext, message: string) => void;
+  reconcileNextDispatchAnnouncementReplyOwnership?: (
+    item: PendingTelegramTurn,
+  ) => void;
   isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
   hasPendingInboundQueueMutationForItem?: (
     item: TelegramQueueItem<TContext>,
@@ -3107,6 +3133,7 @@ export interface TelegramQueueDispatchControllerDeps<
 export interface TelegramQueueDispatchController<TContext = unknown> {
   dispatchNext: (ctx: TContext) => void;
   requestNextDispatchAnnouncement: () => void;
+  cancelNextDispatchAnnouncement: () => void;
 }
 
 export function executeTelegramQueueDispatchPlan<TContext = unknown>(
@@ -3161,6 +3188,8 @@ export function createTelegramQueueDispatchRuntime<TContext = unknown>(
     commitPromptDispatch: deps.commitPromptDispatch,
     sendUserMessage: deps.sendUserMessage,
     onPromptDispatchFailure: deps.onPromptDispatchFailure,
+    reconcileNextDispatchAnnouncementReplyOwnership:
+      deps.reconcileNextDispatchAnnouncementReplyOwnership,
     isQueueItemTransportActive: deps.isQueueItemTransportActive,
     hasPendingInboundQueueMutationForItem:
       deps.hasPendingInboundQueueMutationForItem,
@@ -3176,12 +3205,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
 ): TelegramQueueDispatchController<TContext> {
   let controlDispatchPending = false;
   let nextDispatchAnnouncementRequested = false;
+  let nextDispatchAnnouncementGeneration = 0;
   let nextDispatchAnnouncementAnchor: TelegramQueueItem<TContext> | undefined;
   const controller: TelegramQueueDispatchController<TContext> = {
     requestNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
       nextDispatchAnnouncementRequested = true;
       nextDispatchAnnouncementAnchor = undefined;
     },
+    cancelNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
+      nextDispatchAnnouncementRequested = false;
+      nextDispatchAnnouncementAnchor = undefined;
+    },
     dispatchNext: (ctx) => {
       if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
       if (controlDispatchPending) {
@@ -3393,6 +3429,7 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
       if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
         nextDispatchAnnouncementRequested = false;
         controlDispatchPending = true;
+        const announcementGeneration = nextDispatchAnnouncementGeneration;
         const dispatchGeneration = deps.getDispatchGeneration?.();
         deps.updateStatus(ctx);
         void deps.sendTextReply(
@@ -3401,8 +3438,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
           "<b>⏩ Dispatching next queued turn.</b>",
           { target: dispatchPlan.item.target },
         ).catch((error) => {
-          deps.recordRuntimeEvent?.("dispatch", error, { phase: "next-announcement" });
+          deps.recordRuntimeEvent?.("dispatch", error, {
+            phase: "next-announcement",
+          });
         }).finally(() => {
+          try {
+            deps.reconcileNextDispatchAnnouncementReplyOwnership?.(
+              dispatchPlan.item,
+            );
+          } catch (error) {
+            deps.recordRuntimeEvent?.("dispatch", error, {
+              phase: "next-announcement-reply-ownership",
+            });
+          }
           controlDispatchPending = false;
           if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
           if (
@@ -3410,6 +3458,10 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
             deps.isDispatchGenerationActive &&
             !deps.isDispatchGenerationActive(dispatchGeneration)
           ) return;
+          if (announcementGeneration !== nextDispatchAnnouncementGeneration) {
+            if (nextDispatchAnnouncementRequested) controller.dispatchNext(ctx);
+            return;
+          }
           executePlan();
         });
         return;

package/lib/replies.ts

@@ -68,6 +68,7 @@ export function createReplyDedupRuntime(): ReplyDedupRuntime {
 // --- Transport-level dedup ---
 
 const lastRepliedToMessageIdByTarget = new Map<string, number>();
+const replyDedupPreservedOnNextReset = new Map<string, number>();
 let replyDedupGeneration = 0;
 
 function getReplyDedupTargetKey(
@@ -83,6 +84,23 @@ function getReplyDedupTargetKey(
 export function resetTransportReplyDedup(): void {
   replyDedupGeneration += 1;
   lastRepliedToMessageIdByTarget.clear();
+  for (const [key, messageId] of replyDedupPreservedOnNextReset) {
+    lastRepliedToMessageIdByTarget.set(key, messageId);
+  }
+  replyDedupPreservedOnNextReset.clear();
+}
+
+/** Keeps a successfully published transition notice as the first reply of the
+ * next agent turn. The following agent-start reset consumes this one-shot
+ * preservation, so later messages in that turn do not repeat the reply header. */
+export function preserveTransportReplyDedupOnNextReset(
+  chatId: number,
+  messageId: number,
+  target?: TelegramTarget,
+): void {
+  const key = getReplyDedupTargetKey(chatId, target);
+  if (lastRepliedToMessageIdByTarget.get(key) !== messageId) return;
+  replyDedupPreservedOnNextReset.set(key, messageId);
 }
 
 export function buildTelegramReplyParameters(

package/lib/routing.ts

@@ -627,6 +627,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestNextDispatchAnnouncement?: () => void;
+  cancelNextDispatchAnnouncement?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -1009,7 +1010,6 @@ export function createTelegramInboundRouteRuntime<
     updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
     answerCallbackQuery: deps.answerCallbackQuery,
     isIdle: deps.isIdle,
-    hasActiveTelegramTurn: deps.activeTurnRuntime.has,
     hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
     getActiveToolExecutions:
       deps.bridgeRuntime.lifecycle.getActiveToolExecutions,
@@ -2222,6 +2222,10 @@ export function createTelegramInboundRouteRuntime<
     isContextActive: deps.isContextActive,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
     requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+    cancelNextTransitionAnnouncements: () => {
+      deps.activeTurnRuntime.clearNextAbortAnnouncement();
+      deps.cancelNextDispatchAnnouncement?.();
+    },
     requestDeferredDispatchNextQueuedTelegramTurn:
       deps.requestDeferredDispatchNextQueuedTelegramTurn,
     startTypingLoop: deps.startTypingLoop,
@@ -2297,6 +2301,8 @@ export function createTelegramInboundRouteRuntime<
     },
     getPromptTemplateCommands,
     sendTextReply: deps.sendTextReply,
+    markActiveTurnNextAbortAnnouncement:
+      deps.activeTurnRuntime.markNextAbortAnnouncement,
     getActiveTurnReply: () => {
       const activeTurn = deps.activeTurnRuntime.get();
       if (!activeTurn) return undefined;