@llblab/pi-kit 0.21.2 → 0.22.1

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/telegram-api.ts

@@ -1866,14 +1866,16 @@ export function createTelegramBridgeApiRuntime(
     deps.chatActionMinIntervalMs ?? 2_000,
   );
   const chatActionMaxGates = Math.max(1, deps.chatActionMaxGates ?? 256);
-  const chatActionGates = new Map<
-    string,
-    { inFlight?: Promise<unknown>; notBeforeMs: number }
-  >();
-  const getChatActionKey = (
+  type ChatActionGate = {
+    inFlight?: Promise<unknown>;
+    notBeforeMs: number;
+  };
+  const chatActionGates = new Map<string, ChatActionGate>();
+  const chatActionChatGates = new Map<string, ChatActionGate>();
+  const getChatActionKeys = (
     method: string,
     body: Record<string, unknown>,
-  ): string | undefined => {
+  ): { action: string; chat: string } | undefined => {
     if (method !== "sendChatAction") return undefined;
     const chatId = body.chat_id;
     const action = body.action;
@@ -1883,12 +1885,16 @@ export function createTelegramBridgeApiRuntime(
     ) {
       return undefined;
     }
+    const chat = String(chatId);
     const threadId = body.message_thread_id;
-    return `${String(chatId)}:${
-      typeof threadId === "number" || typeof threadId === "string"
-        ? String(threadId)
-        : "all"
-    }:${action}`;
+    return {
+      action: `${chat}:${
+        typeof threadId === "number" || typeof threadId === "string"
+          ? String(threadId)
+          : "all"
+      }:${action}`,
+      chat,
+    };
   };
   const callRecorded = async <TResponse>(
     method: string,
@@ -1896,22 +1902,38 @@ export function createTelegramBridgeApiRuntime(
     options?: TelegramApiCallOptions,
   ): Promise<TResponse> => {
     const recoverError = deps.captureRequestErrorHandler?.(body);
-    const chatActionKey = getChatActionKey(method, body);
-    if (chatActionKey) {
+    const chatActionKeys = getChatActionKeys(method, body);
+    if (chatActionKeys) {
       const nowMs = now();
       for (const [key, candidate] of chatActionGates) {
         if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
           chatActionGates.delete(key);
         }
       }
-      let gate = chatActionGates.get(chatActionKey);
+      for (const [key, candidate] of chatActionChatGates) {
+        if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
+          chatActionChatGates.delete(key);
+        }
+      }
+      let gate = chatActionGates.get(chatActionKeys.action);
       if (!gate) {
         if (chatActionGates.size >= chatActionMaxGates) return true as TResponse;
         gate = { notBeforeMs: 0 };
-        chatActionGates.set(chatActionKey, gate);
+        chatActionGates.set(chatActionKeys.action, gate);
+      }
+      let chatGate = chatActionChatGates.get(chatActionKeys.chat);
+      if (!chatGate) {
+        if (chatActionChatGates.size >= chatActionMaxGates) {
+          return true as TResponse;
+        }
+        chatGate = { notBeforeMs: 0 };
+        chatActionChatGates.set(chatActionKeys.chat, chatGate);
       }
       if (gate.inFlight) return (await gate.inFlight) as TResponse;
-      if (now() < gate.notBeforeMs) return true as TResponse;
+      if (chatGate.inFlight) return true as TResponse;
+      if (nowMs < gate.notBeforeMs || nowMs < chatGate.notBeforeMs) {
+        return true as TResponse;
+      }
       let request: Promise<TResponse>;
       request = Promise.resolve()
         .then(() =>
@@ -1931,7 +1953,9 @@ export function createTelegramBridgeApiRuntime(
               chatActionMinIntervalMs,
               (error.retryAfterSeconds ?? 0) * 1_000,
             );
-            gate.notBeforeMs = now() + retryAfterMs;
+            const notBeforeMs = now() + retryAfterMs;
+            gate.notBeforeMs = notBeforeMs;
+            chatGate.notBeforeMs = Math.max(chatGate.notBeforeMs, notBeforeMs);
             deps.recordRuntimeEvent(
               "api",
               error,
@@ -1952,8 +1976,10 @@ export function createTelegramBridgeApiRuntime(
         })
         .finally(() => {
           if (gate.inFlight === request) gate.inFlight = undefined;
+          if (chatGate.inFlight === request) chatGate.inFlight = undefined;
         });
       gate.inFlight = request;
+      chatGate.inFlight = request;
       return request;
     }
     try {

package/node_modules/@llblab/pi-telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.51.1",
+  "version": "0.51.2",
   "private": false,
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.21.2",
+  "version": "0.22.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -41,11 +41,11 @@
   ],
   "dependencies": {
     "@llblab/pi-actors": "0.53.0",
-    "@llblab/pi-clean-room": "0.1.1",
+    "@llblab/pi-clean-room": "0.2.0",
     "@llblab/pi-codex-usage": "0.10.0",
     "@llblab/pi-grow-loop": "0.8.1",
     "@llblab/pi-state-flow": "0.18.1",
-    "@llblab/pi-telegram": "0.51.1",
+    "@llblab/pi-telegram": "0.51.2",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [