@llblab/pi-telegram 0.51.0 → 0.51.2

package/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/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/package.json

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