@llblab/pi-telegram 0.51.0 → 0.51.2

package/dist/lib/model.js

@@ -261,12 +261,12 @@ export function createPendingModelSwitchStore() {
         has: () => selection !== undefined,
     };
 }
-export function canRestartTelegramTurnForModelSwitch(state) {
-    return !state.isIdle && state.hasActiveTelegramTurn && state.hasAbortHandler;
+export function canRestartAgentRunForTelegramModelSwitch(state) {
+    return !state.isIdle && state.hasAbortHandler;
 }
 export function shouldTriggerPendingTelegramModelSwitchAbort(state) {
     return (state.hasPendingModelSwitch &&
-        state.hasActiveTelegramTurn &&
+        state.hasContinuationTurn &&
         state.hasAbortHandler &&
         state.activeToolExecutions === 0);
 }
@@ -297,7 +297,7 @@ export function buildTelegramModelSwitchContinuationText(telegramPrefix, model,
     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 function buildTelegramModelSwitchContinuationTurn(options) {
     const modelLabel = `${options.selection.model.provider}/${options.selection.model.id}`;
@@ -318,7 +318,7 @@ export function buildTelegramModelSwitchContinuationTurn(options) {
                 text: buildTelegramModelSwitchContinuationText(options.telegramPrefix ?? TELEGRAM_PREFIX, options.selection.model, options.selection.thinkingLevel),
             },
         ],
-        historyText: `Continue interrupted Telegram request on ${modelLabel}`,
+        historyText: `Continue interrupted request on ${modelLabel}`,
         statusSummary: `↻ ${statusLabel || "continue"}`,
     };
 }
@@ -364,46 +364,60 @@ export function createTelegramModelSwitchControllerRuntime(deps) {
     });
 }
 export function createTelegramModelSwitchController(deps) {
+    let pendingContinuationTurn;
+    const triggerPendingAbort = (ctx) => {
+        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({
+        canOfferInFlightSwitch: (ctx) => 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;
+        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;
         },
-        restartInterruptedTurn: (selection, ctx) => restartTelegramModelSwitchContinuation({
-            activeTurn: deps.getActiveTurn(),
-            abort: deps.getAbortHandler(),
-            selection,
-            queueContinuation: (turn, nextSelection) => {
-                deps.queueContinuation(turn, nextSelection, ctx);
-            },
-        }),
     };
 }

package/dist/lib/queue.d.ts

@@ -84,6 +84,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;
     /** Turn must be delivered as voice (voice mode) */
@@ -165,6 +167,8 @@ export interface TelegramActiveTurnStore<TTurn extends PendingTelegramTurn = Pen
     has: () => boolean;
     set: (turn: TTurn) => void;
     clear: () => void;
+    markNextAbortAnnouncement: () => boolean;
+    clearNextAbortAnnouncement: () => boolean;
     getChatId: () => number | undefined;
     getTarget: () => TelegramQueueTarget | undefined;
     getReplyToMessageId: () => number | undefined;
@@ -349,7 +353,6 @@ export interface TelegramAgentStartHookRuntimeDeps<TTurn extends PendingTelegram
 }
 export type TelegramAgentStartHookEvent = unknown;
 export interface TelegramToolExecutionRuntimeDeps {
-    hasActiveTurn: () => boolean;
     getActiveToolExecutions: () => number;
     setActiveToolExecutions: (count: number) => void;
 }
@@ -368,7 +371,6 @@ export declare function buildTelegramAgentStartPlan<TContext = unknown>(options:
 export declare function handleTelegramAgentStartRuntime<TTurn extends PendingTelegramTurn, TContext = unknown>(deps: TelegramAgentStartRuntimeDeps<TTurn, TContext>): void;
 export declare function createTelegramAgentStartHook<TTurn extends PendingTelegramTurn, TContext = unknown>(deps: TelegramAgentStartHookRuntimeDeps<TTurn, TContext>): (_event: TelegramAgentStartHookEvent, ctx: TContext) => Promise<void>;
 export declare function getNextTelegramToolExecutionCount(options: {
-    hasActiveTurn: boolean;
     currentCount: number;
     event: "start" | "end";
 }): number;
@@ -391,6 +393,7 @@ export interface TelegramAgentEndPlan {
     kind: "no-turn" | "aborted" | "error" | "text" | "attachments-only" | "empty";
     shouldClearPreview: boolean;
     shouldDispatchNext: boolean;
+    shouldSendAbortMessage: boolean;
     shouldSendErrorMessage: boolean;
     shouldSendAttachmentNotice: boolean;
 }
@@ -517,6 +520,7 @@ export declare function buildTelegramAgentEndPlan(options: {
     hasFinalText: boolean;
     hasQueuedAttachments: boolean;
     foldQueuedPromptsIntoHistory: boolean;
+    announceNextAbortOnEnd?: boolean;
 }): TelegramAgentEndPlan;
 export declare function createTelegramAgentEndHook<TTurn extends PendingTelegramTurn, TContext, TMessage, TReplyMarkup = unknown>(deps: TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage, TReplyMarkup>): (event: TelegramAgentEndHookEvent<TMessage>, ctx: TContext, assistantOverride?: TelegramAgentEndAssistantResult) => Promise<void>;
 export declare function handleTelegramAgentEndRuntime<TTurn extends PendingTelegramTurn, TReplyMarkup = unknown>(deps: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>): Promise<void>;
@@ -759,6 +763,7 @@ export interface TelegramQueueDispatchControllerDeps<TContext = unknown> extends
     }>["item"], ctx: TContext) => boolean;
     sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
+    reconcileNextDispatchAnnouncementReplyOwnership?: (item: PendingTelegramTurn) => void;
     isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
     hasPendingInboundQueueMutationForItem?: (item: TelegramQueueItem<TContext>) => boolean;
     isQueueItemAdmissionReady?: (item: TelegramQueueItem<TContext>) => boolean;
@@ -768,6 +773,7 @@ export interface TelegramQueueDispatchControllerDeps<TContext = unknown> extends
 export interface TelegramQueueDispatchController<TContext = unknown> {
     dispatchNext: (ctx: TContext) => void;
     requestNextDispatchAnnouncement: () => void;
+    cancelNextDispatchAnnouncement: () => void;
 }
 export declare function executeTelegramQueueDispatchPlan<TContext = unknown>(plan: TelegramQueueDispatchAction<TContext>, deps: TelegramDispatchRuntimeDeps<TContext>): void;
 export type TelegramQueueDispatchRuntimeDeps<TContext = unknown> = Omit<TelegramQueueDispatchControllerDeps<TContext>, "canDispatch"> & TelegramDispatchReadinessDeps<TContext>;

package/dist/lib/queue.js

@@ -168,6 +168,18 @@ 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,
         getReplyToMessageId: () => activeTurn?.replyToMessageId,
@@ -729,8 +741,6 @@ export function createTelegramAgentStartHook(deps) {
     };
 }
 export function getNextTelegramToolExecutionCount(options) {
-    if (!options.hasActiveTurn)
-        return options.currentCount;
     if (options.event === "start") {
         return options.currentCount + 1;
     }
@@ -738,20 +748,16 @@ export function getNextTelegramToolExecutionCount(options) {
 }
 export function handleTelegramToolExecutionStartRuntime(deps) {
     deps.setActiveToolExecutions(getNextTelegramToolExecutionCount({
-        hasActiveTurn: deps.hasActiveTurn(),
         currentCount: deps.getActiveToolExecutions(),
         event: "start",
     }));
 }
 export function handleTelegramToolExecutionEndRuntime(deps) {
-    const hasActiveTurn = deps.hasActiveTurn();
     deps.setActiveToolExecutions(getNextTelegramToolExecutionCount({
-        hasActiveTurn,
         currentCount: deps.getActiveToolExecutions(),
         event: "end",
     }));
-    if (hasActiveTurn)
-        deps.triggerPendingModelSwitchAbort();
+    deps.triggerPendingModelSwitchAbort();
 }
 export function createTelegramAgentLifecycleHooks(deps) {
     const onAgentStart = createTelegramAgentStartHook(deps);
@@ -794,7 +800,6 @@ export function createTelegramToolExecutionHooks(deps) {
         },
         onToolExecutionEnd: (_event, ctx) => {
             handleTelegramToolExecutionEndRuntime({
-                hasActiveTurn: deps.hasActiveTurn,
                 getActiveToolExecutions: deps.getActiveToolExecutions,
                 setActiveToolExecutions: deps.setActiveToolExecutions,
                 triggerPendingModelSwitchAbort: () => {
@@ -815,6 +820,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "no-turn",
             shouldClearPreview: false,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -824,6 +830,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "aborted",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: options.announceNextAbortOnEnd === true,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -833,6 +840,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "error",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: true,
             shouldSendAttachmentNotice: false,
         };
@@ -842,6 +850,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "text",
             shouldClearPreview: false,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -851,6 +860,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "attachments-only",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: true,
         };
@@ -859,6 +869,7 @@ export function buildTelegramAgentEndPlan(options) {
         kind: "empty",
         shouldClearPreview: true,
         shouldDispatchNext,
+        shouldSendAbortMessage: false,
         shouldSendErrorMessage: false,
         shouldSendAttachmentNotice: false,
     };
@@ -991,6 +1002,7 @@ export async function handleTelegramAgentEndRuntime(deps) {
         hasFinalText: !!finalText || hasOutboundArtifacts,
         hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
         foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
+        announceNextAbortOnEnd: turn?.announceNextAbortOnEnd === true,
     });
     if (!turn) {
         if (endPlan.shouldDispatchNext)
@@ -1116,17 +1128,26 @@ export async function handleTelegramAgentEndRuntime(deps) {
             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" } : {}),
-            });
+            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" } : {}),
+                });
+            }
+            catch (error) {
+                if (!isOperationAborted)
+                    throw error;
+                deps.recordRuntimeEvent?.("dispatch", error, {
+                    phase: "next-abort-announcement",
+                });
+            }
             if (!isDeliveryActive())
                 return;
             if (endPlan.shouldDispatchNext)
@@ -1267,7 +1288,7 @@ export async function handleTelegramAgentEndRuntime(deps) {
             deps.dispatchNextQueuedTelegramTurn();
     };
     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;
     }
@@ -1765,6 +1786,7 @@ export function createTelegramQueueDispatchRuntime(deps) {
         commitPromptDispatch: deps.commitPromptDispatch,
         sendUserMessage: deps.sendUserMessage,
         onPromptDispatchFailure: deps.onPromptDispatchFailure,
+        reconcileNextDispatchAnnouncementReplyOwnership: deps.reconcileNextDispatchAnnouncementReplyOwnership,
         isQueueItemTransportActive: deps.isQueueItemTransportActive,
         hasPendingInboundQueueMutationForItem: deps.hasPendingInboundQueueMutationForItem,
         isQueueItemAdmissionReady: deps.isQueueItemAdmissionReady,
@@ -1776,12 +1798,19 @@ export function createTelegramQueueDispatchRuntime(deps) {
 export function createTelegramQueueDispatchController(deps) {
     let controlDispatchPending = false;
     let nextDispatchAnnouncementRequested = false;
+    let nextDispatchAnnouncementGeneration = 0;
     let nextDispatchAnnouncementAnchor;
     const controller = {
         requestNextDispatchAnnouncement: () => {
+            nextDispatchAnnouncementGeneration += 1;
             nextDispatchAnnouncementRequested = true;
             nextDispatchAnnouncementAnchor = undefined;
         },
+        cancelNextDispatchAnnouncement: () => {
+            nextDispatchAnnouncementGeneration += 1;
+            nextDispatchAnnouncementRequested = false;
+            nextDispatchAnnouncementAnchor = undefined;
+        },
         dispatchNext: (ctx) => {
             if (deps.hasDispatchContext && !deps.hasDispatchContext())
                 return;
@@ -1972,11 +2001,22 @@ export function createTelegramQueueDispatchController(deps) {
             if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
                 nextDispatchAnnouncementRequested = false;
                 controlDispatchPending = true;
+                const announcementGeneration = nextDispatchAnnouncementGeneration;
                 const dispatchGeneration = deps.getDispatchGeneration?.();
                 deps.updateStatus(ctx);
                 void deps.sendTextReply(dispatchPlan.item.chatId, dispatchPlan.item.replyToMessageId, "<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;
@@ -1984,6 +2024,11 @@ export function createTelegramQueueDispatchController(deps) {
                         deps.isDispatchGenerationActive &&
                         !deps.isDispatchGenerationActive(dispatchGeneration))
                         return;
+                    if (announcementGeneration !== nextDispatchAnnouncementGeneration) {
+                        if (nextDispatchAnnouncementRequested)
+                            controller.dispatchNext(ctx);
+                        return;
+                    }
                     executePlan();
                 });
                 return;

package/dist/lib/replies.d.ts

@@ -23,6 +23,10 @@ export interface ReplyDedupRuntime {
 }
 export declare function createReplyDedupRuntime(): ReplyDedupRuntime;
 export declare function resetTransportReplyDedup(): void;
+/** 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 declare function preserveTransportReplyDedupOnNextReset(chatId: number, messageId: number, target?: TelegramTarget): void;
 export declare function buildTelegramReplyParameters(chatId: number, messageId: number | undefined, target?: TelegramTarget): TelegramReplyParameters | undefined;
 export declare function withTelegramReplyParameters<T>(chatId: number, messageId: number | undefined, target: TelegramTarget | undefined, send: (parameters: TelegramReplyParameters | undefined) => Promise<T>): Promise<T>;
 export declare function isAssistantAgentMessage(message: unknown): boolean;

package/dist/lib/replies.js

@@ -31,6 +31,7 @@ export function createReplyDedupRuntime() {
 }
 // --- Transport-level dedup ---
 const lastRepliedToMessageIdByTarget = new Map();
+const replyDedupPreservedOnNextReset = new Map();
 let replyDedupGeneration = 0;
 function getReplyDedupTargetKey(chatId, target) {
     const threadId = target?.threadId;
@@ -41,6 +42,19 @@ function getReplyDedupTargetKey(chatId, target) {
 export function resetTransportReplyDedup() {
     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, messageId, target) {
+    const key = getReplyDedupTargetKey(chatId, target);
+    if (lastRepliedToMessageIdByTarget.get(key) !== messageId)
+        return;
+    replyDedupPreservedOnNextReset.set(key, messageId);
 }
 export function buildTelegramReplyParameters(chatId, messageId, target) {
     if (messageId === undefined || messageId <= 0)

package/dist/lib/routing.d.ts

@@ -122,6 +122,7 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     isContextActive?: (ctx: TContext) => boolean;
     dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
     requestNextDispatchAnnouncement?: () => void;
+    cancelNextDispatchAnnouncement?: () => void;
     requestDeferredDispatchNextQueuedTelegramTurn?: (dispatch: (ctx: TContext) => void) => void;
     hasDeferredDispatchContext?: () => boolean;
     startTypingLoop?: (ctx: TContext, chatId?: number, options?: {

package/dist/lib/routing.js

@@ -535,7 +535,6 @@ export function createTelegramInboundRouteRuntime(deps) {
         updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
         answerCallbackQuery: deps.answerCallbackQuery,
         isIdle: deps.isIdle,
-        hasActiveTelegramTurn: deps.activeTurnRuntime.has,
         hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
         getActiveToolExecutions: deps.bridgeRuntime.lifecycle.getActiveToolExecutions,
         persistScopedModelPatterns: deps.persistScopedModelPatterns,
@@ -1418,6 +1417,10 @@ export function createTelegramInboundRouteRuntime(deps) {
         isContextActive: deps.isContextActive,
         dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
         requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+        cancelNextTransitionAnnouncements: () => {
+            deps.activeTurnRuntime.clearNextAbortAnnouncement();
+            deps.cancelNextDispatchAnnouncement?.();
+        },
         requestDeferredDispatchNextQueuedTelegramTurn: deps.requestDeferredDispatchNextQueuedTelegramTurn,
         startTypingLoop: deps.startTypingLoop,
         stopTypingLoop: deps.stopTypingLoop,
@@ -1476,6 +1479,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         },
         getPromptTemplateCommands,
         sendTextReply: deps.sendTextReply,
+        markActiveTurnNextAbortAnnouncement: deps.activeTurnRuntime.markNextAbortAnnouncement,
         getActiveTurnReply: () => {
             const activeTurn = deps.activeTurnRuntime.get();
             if (!activeTurn)

package/dist/lib/runtime.d.ts

@@ -98,7 +98,6 @@ export interface TelegramTypingLoopDeps {
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     shouldContinue?: () => boolean;
     onStopped?: () => void;
 }
@@ -111,7 +110,6 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;
     isTransportAvailable?: () => boolean;
@@ -120,7 +118,7 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
 }
 export declare function createTelegramTypingLoopStarter<TContext>(deps: TelegramTypingLoopStarterDeps<TContext>): (ctx: TContext, chatId?: number, options?: {
     target?: TelegramTypingLoopTarget;
-}) => void;
+}) => boolean;
 export declare function startTelegramTypingLoop(state: TelegramBridgeRuntimeState, deps: TelegramTypingLoopDeps): boolean;
 export declare function stopTelegramTypingLoop(state: TelegramBridgeRuntimeState): boolean;
 export declare function waitForTelegramTypingLoopIdle(state: TelegramBridgeRuntimeState, timeoutMs?: number): Promise<void>;
@@ -141,7 +139,7 @@ export interface TelegramPromptDispatchLifecycleDeps<TContext> extends TelegramR
     typing: Pick<TelegramRuntimeTypingPort, "stop">;
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
-    }) => void;
+    }) => boolean | void;
     updateStatus: (ctx: TContext, error?: string) => void;
 }
 export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRuntimeEventRecorderPort {
@@ -151,7 +149,6 @@ export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRun
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;
     isTransportAvailable?: () => boolean;
@@ -161,7 +158,7 @@ export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRun
 export interface TelegramPromptDispatchRuntime<TContext> {
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
-    }) => void;
+    }) => boolean | void;
     onPromptDispatchStart: (ctx: TContext, chatId?: number) => void;
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
 }

package/dist/lib/runtime.js

@@ -3,7 +3,7 @@
  * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
-const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3_000;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 export function createTelegramBridgeRuntimeState() {
     return {
@@ -177,9 +177,9 @@ export function createTelegramTypingLoopStarter(deps) {
                 Object.is(deps.getTransportAuthority(), transportAuthority)
             : deps.isTransportAvailable?.() !== false;
         if (!hasTransport())
-            return;
+            return false;
         let active = true;
-        deps.typing.start({
+        return deps.typing.start({
             chatId: chatId ?? deps.getDefaultChatId(),
             target: options?.target,
             intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
@@ -202,13 +202,6 @@ export function createTelegramTypingLoopStarter(deps) {
                         deps.typing.stop();
                         return;
                     }
-                    const message = error instanceof Error ? error.message : String(error);
-                    updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
-                        error: message,
-                        category: "typing",
-                        phase: "status-update",
-                        recordRuntimeEvent: deps.recordRuntimeEvent,
-                    });
                     try {
                         deps.recordRuntimeEvent?.("typing", error, {
                             chatId: targetChatId,
@@ -219,45 +212,6 @@ export function createTelegramTypingLoopStarter(deps) {
                     }
                 }
             },
-            sendAggregateTypingAction: deps.sendAggregateTypingAction
-                ? async (targetChatId) => {
-                    if (!active)
-                        return;
-                    if (!hasTransport()) {
-                        deps.typing.stop();
-                        return;
-                    }
-                    try {
-                        await deps.sendAggregateTypingAction?.(targetChatId);
-                    }
-                    catch (error) {
-                        if (deps.isContextActive?.(ctx) === false)
-                            return;
-                        if (!active)
-                            return;
-                        if (!hasTransport()) {
-                            deps.typing.stop();
-                            return;
-                        }
-                        const message = error instanceof Error ? error.message : String(error);
-                        updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
-                            error: message,
-                            category: "typing",
-                            phase: "status-update",
-                            recordRuntimeEvent: deps.recordRuntimeEvent,
-                        });
-                        try {
-                            deps.recordRuntimeEvent?.("typing", error, {
-                                chatId: targetChatId,
-                                aggregate: true,
-                            });
-                        }
-                        catch {
-                            // Typing diagnostics cannot escape the in-flight action owner.
-                        }
-                    }
-                }
-                : undefined,
             shouldContinue: hasTransport,
             onStopped: () => {
                 active = false;
@@ -296,12 +250,7 @@ export function startTelegramTypingLoop(state, deps) {
         const targetChatId = activeDeps.chatId;
         const threadParams = getTelegramTypingLoopThreadParams(activeDeps.target);
         const typing = Promise.resolve()
-            .then(async () => {
-            await activeDeps.sendTypingAction(targetChatId, threadParams);
-            if (threadParams?.message_thread_id !== undefined) {
-                await activeDeps.sendAggregateTypingAction?.(targetChatId);
-            }
-        })
+            .then(() => activeDeps.sendTypingAction(targetChatId, threadParams))
             .then(() => undefined)
             .catch(() => undefined);
         state.typingInFlight = typing;