@llblab/pi-kit 0.22.0 → 0.22.2

package/node_modules/@llblab/pi-telegram/lib/menu-model.ts

@@ -13,6 +13,7 @@ import {
   resolveScopedModelPatterns,
   type ScopedTelegramModel,
   sortScopedModels,
+  type TelegramModelSwitchContinuationSource,
   type ThinkingLevel,
 } from "./model.ts";
 
@@ -157,9 +158,13 @@ export type TelegramModelMenuCallbackDeps<
   setModel: (model: TModel) => Promise<boolean>;
   setCurrentModel: (model: TModel) => void;
   setThinkingLevel: (level: ThinkingLevel) => void;
-  stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>) => void;
+  stagePendingModelSwitch: (
+    selection: ScopedTelegramModel<TModel>,
+    continuationTurn: TelegramModelSwitchContinuationSource,
+  ) => void;
   restartInterruptedTelegramTurn: (
     selection: ScopedTelegramModel<TModel>,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => Promise<boolean> | boolean;
 };
 
@@ -961,14 +966,28 @@ export async function handleTelegramModelMenuCallbackAction<
   if (plan.selection.thinkingLevel) {
     deps.setThinkingLevel(plan.selection.thinkingLevel);
   }
-  await deps.updateModelMenuMessage();
+  const continuationTurn: TelegramModelSwitchContinuationSource = {
+    chatId: params.state.chatId,
+    replyToMessageId: params.state.messageId,
+    target: {
+      chatId: params.state.chatId,
+      ...(params.state.threadId === undefined
+        ? {}
+        : { threadId: params.state.threadId }),
+    },
+  };
   if (plan.mode === "restart-after-tool") {
-    deps.stagePendingModelSwitch(plan.selection);
+    deps.stagePendingModelSwitch(plan.selection, continuationTurn);
+    await deps.updateModelMenuMessage();
     await deps.answerCallbackQuery(callbackQueryId, plan.callbackText);
     return true;
   }
   if (plan.mode === "restart-now") {
-    const restarted = await deps.restartInterruptedTelegramTurn(plan.selection);
+    const restarted = await deps.restartInterruptedTelegramTurn(
+      plan.selection,
+      continuationTurn,
+    );
+    await deps.updateModelMenuMessage();
     if (!restarted) {
       await deps.answerCallbackQuery(
         callbackQueryId,
@@ -976,6 +995,8 @@ export async function handleTelegramModelMenuCallbackAction<
       );
       return true;
     }
+  } else {
+    await deps.updateModelMenuMessage();
   }
   await deps.answerCallbackQuery(callbackQueryId, plan.callbackText);
   return true;

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

@@ -30,6 +30,7 @@ import {
 import {
   type MenuModel,
   type ScopedTelegramModel,
+  type TelegramModelSwitchContinuationSource,
   type ThinkingLevel,
 } from "./model.ts";
 import type { TelegramInputRichMessage } from "./telegram-api.ts";
@@ -194,7 +195,6 @@ export interface TelegramMenuCallbackRuntimeDeps<
     text?: string,
   ) => Promise<void>;
   isIdle: (ctx: TContext) => boolean;
-  hasActiveTelegramTurn: () => boolean;
   hasAbortHandler: () => boolean;
   hasActiveToolExecutions: () => boolean;
   persistScopedModelPatterns?: (
@@ -206,10 +206,12 @@ export interface TelegramMenuCallbackRuntimeDeps<
   stagePendingModelSwitch: (
     selection: ScopedTelegramModel<TModel>,
     ctx: TContext,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => void;
   restartInterruptedTelegramTurn: (
     selection: ScopedTelegramModel<TModel>,
     ctx: TContext,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => Promise<boolean> | boolean;
   sectionRegistry?: TelegramSectionRegistry;
   editInteractiveMessage?: (
@@ -452,7 +454,6 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
     text?: string,
   ) => Promise<void>;
   isIdle: (ctx: TContext) => boolean;
-  hasActiveTelegramTurn: () => boolean;
   hasAbortHandler: () => boolean;
   getActiveToolExecutions: () => number;
   persistScopedModelPatterns?: (
@@ -464,10 +465,12 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
   stagePendingModelSwitch: (
     selection: ScopedTelegramModel<TModel>,
     ctx: TContext,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => void;
   restartInterruptedTelegramTurn: (
     selection: ScopedTelegramModel<TModel>,
     ctx: TContext,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => Promise<boolean> | boolean;
   sectionRegistry?: TelegramSectionRegistry;
   editInteractiveMessage?: (
@@ -527,7 +530,6 @@ export function createTelegramMenuCallbackHandlerForContext<
     updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
     answerCallbackQuery: deps.answerCallbackQuery,
     isIdle: deps.isIdle,
-    hasActiveTelegramTurn: deps.hasActiveTelegramTurn,
     hasAbortHandler: deps.hasAbortHandler,
     hasActiveToolExecutions: () => deps.getActiveToolExecutions() > 0,
     persistScopedModelPatterns: deps.persistScopedModelPatterns,
@@ -715,8 +717,7 @@ export async function handleTelegramMenuCallbackRuntime<
             activeModel: deps.getActiveModel(ctx),
             currentThinkingLevel: deps.getThinkingLevel(),
             isIdle: deps.isIdle(ctx),
-            canRestartBusyRun:
-              deps.hasActiveTelegramTurn() && deps.hasAbortHandler(),
+            canRestartBusyRun: deps.hasAbortHandler(),
             hasActiveToolExecutions: deps.hasActiveToolExecutions(),
           },
           {
@@ -733,11 +734,15 @@ export async function handleTelegramMenuCallbackRuntime<
               deps.setThinkingLevel(level);
               deps.updateStatus(ctx);
             },
-            stagePendingModelSwitch: (selection) => {
-              deps.stagePendingModelSwitch(selection, ctx);
+            stagePendingModelSwitch: (selection, continuationTurn) => {
+              deps.stagePendingModelSwitch(selection, ctx, continuationTurn);
             },
-            restartInterruptedTelegramTurn: (selection) =>
-              deps.restartInterruptedTelegramTurn(selection, ctx),
+            restartInterruptedTelegramTurn: (selection, continuationTurn) =>
+              deps.restartInterruptedTelegramTurn(
+                selection,
+                ctx,
+                continuationTurn,
+              ),
           },
         );
       } catch (error) {

package/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/lib/queue.ts

@@ -1253,7 +1253,6 @@ export interface TelegramAgentStartHookRuntimeDeps<
 export type TelegramAgentStartHookEvent = unknown;
 
 export interface TelegramToolExecutionRuntimeDeps {
-  hasActiveTurn: () => boolean;
   getActiveToolExecutions: () => number;
   setActiveToolExecutions: (count: number) => void;
 }
@@ -1361,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;
   }
@@ -1377,7 +1374,6 @@ export function handleTelegramToolExecutionStartRuntime(
 ): void {
   deps.setActiveToolExecutions(
     getNextTelegramToolExecutionCount({
-      hasActiveTurn: deps.hasActiveTurn(),
       currentCount: deps.getActiveToolExecutions(),
       event: "start",
     }),
@@ -1387,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<
@@ -1485,7 +1479,6 @@ export function createTelegramToolExecutionHooks<TContext>(
       ctx: TContext,
     ): void => {
       handleTelegramToolExecutionEndRuntime({
-        hasActiveTurn: deps.hasActiveTurn,
         getActiveToolExecutions: deps.getActiveToolExecutions,
         setActiveToolExecutions: deps.setActiveToolExecutions,
         triggerPendingModelSwitchAbort: () => {

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

@@ -1010,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,

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

@@ -4,7 +4,7 @@
  * 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 interface TelegramRuntimeQueueCounters {
@@ -319,7 +319,6 @@ export interface TelegramTypingLoopDeps {
     chatId: number,
     options?: { message_thread_id?: number },
   ) => Promise<unknown>;
-  sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
   shouldContinue?: () => boolean;
   onStopped?: () => void;
 }
@@ -364,7 +363,6 @@ export interface TelegramTypingLoopStarterDeps<
     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;
@@ -378,7 +376,7 @@ export function createTelegramTypingLoopStarter<TContext>(
   ctx: TContext,
   chatId?: number,
   options?: { target?: TelegramTypingLoopTarget },
-) => void {
+) => boolean {
   return (ctx, chatId, options) => {
     const transportAuthority = deps.getTransportAuthority?.();
     const hasTransport = (): boolean =>
@@ -386,9 +384,9 @@ export function createTelegramTypingLoopStarter<TContext>(
         ? transportAuthority !== undefined &&
           Object.is(deps.getTransportAuthority(), transportAuthority)
         : deps.isTransportAvailable?.() !== false;
-    if (!hasTransport()) return;
+    if (!hasTransport()) 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,
@@ -407,14 +405,6 @@ export function createTelegramTypingLoopStarter<TContext>(
             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,
@@ -424,41 +414,6 @@ export function createTelegramTypingLoopStarter<TContext>(
           }
         }
       },
-      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;
@@ -502,12 +457,7 @@ export function startTelegramTypingLoop(
     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;
@@ -602,7 +552,7 @@ export interface TelegramPromptDispatchLifecycleDeps<
     ctx: TContext,
     chatId?: number,
     options?: { target?: TelegramTypingLoopTarget },
-  ) => void;
+  ) => boolean | void;
   updateStatus: (ctx: TContext, error?: string) => void;
 }
 
@@ -616,7 +566,6 @@ export interface TelegramPromptDispatchRuntimeDeps<
     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;
@@ -629,7 +578,7 @@ export interface TelegramPromptDispatchRuntime<TContext> {
     ctx: TContext,
     chatId?: number,
     options?: { target?: TelegramTypingLoopTarget },
-  ) => void;
+  ) => boolean | void;
   onPromptDispatchStart: (ctx: TContext, chatId?: number) => void;
   onPromptDispatchFailure: (ctx: TContext, message: string) => void;
 }

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

@@ -1,21 +1,29 @@
 /**
  * Bundled Telegram skill discovery
  * Zones: pi agent, telegram guidance
- * Owns source-checkout and installed-package skill path contribution
+ * Owns source-checkout skill contribution; installed packages use their manifest
  */
 
+import { extname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import type { ExtensionAPI } from "./pi.ts";
 
+const TELEGRAM_SKILLS_MODULE_PATH = fileURLToPath(import.meta.url);
+
 export const TELEGRAM_SKILLS_PATH = fileURLToPath(
   new URL("../skills", import.meta.url),
 );
 
 export function registerTelegramSkillDiscovery(
   pi: Pick<ExtensionAPI, "on">,
-): void {
+  modulePath = TELEGRAM_SKILLS_MODULE_PATH,
+): boolean {
+  // A raw source extension has no package manifest owner. Compiled npm/git
+  // packages do, so contributing again would bypass their resource filters.
+  if (extname(modulePath) !== ".ts") return false;
   pi.on("resources_discover", () => ({
     skillPaths: [TELEGRAM_SKILLS_PATH],
   }));
+  return true;
 }