@llblab/pi-telegram 0.36.9 → 0.36.10

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.36.10: Transport-Fenced Typing Hotfix
+
+- `Typing Authority Fence`: Starts and continues Telegram typing activity only while the Pi instance has direct ownership or a live follower registration, stopping quietly when authority disappears so classic takeover cannot re-arm a stale loop or flood diagnostics with expected follower-registration errors.
+
 ## 0.36.9: Telegram Status And Generated Controls Hotfix
 
 - `Classic Takeover Status`: Keeps a classic-mode client visibly `disconnected` after another Pi instance takes Telegram ownership, preventing stale transport-side activity errors from overriding the authoritative connection state.

package/index.ts

@@ -465,6 +465,15 @@ export default function (pi: Pi.ExtensionAPI) {
       BusApi.createTelegramAggregateTypingActionSender(telegramApiRuntime),
     updateStatus,
     isContextActive: telegramSessionContextStore.isCurrent,
+    getTransportAuthority() {
+      if (ownsTelegramDirectDelivery()) {
+        const epoch = getCurrentLeaderEpoch();
+        return epoch === undefined ? undefined : `direct:${epoch}`;
+      }
+      if (!telegramBusFollowerRegistrationState.isRegistered()) return undefined;
+      const generation = telegramBusFollowerRegistrationState.getGeneration();
+      return generation ? `follower:${generation}` : undefined;
+    },
     recordRuntimeEvent,
   });
   const currentModelRuntime = Model.createCurrentModelRuntime({

package/lib/runtime.ts

@@ -320,6 +320,8 @@ export interface TelegramTypingLoopDeps {
     options?: { message_thread_id?: number },
   ) => Promise<unknown>;
   sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
+  shouldContinue?: () => boolean;
+  onStopped?: () => void;
 }
 
 export interface TelegramRuntimeEventRecorderPort {
@@ -365,6 +367,8 @@ export interface TelegramTypingLoopStarterDeps<
   sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
   updateStatus: (ctx: TContext, error?: string) => void;
   isContextActive?: (ctx: TContext) => boolean;
+  isTransportAvailable?: () => boolean;
+  getTransportAuthority?: () => string | number | undefined;
   intervalMs?: number;
 }
 
@@ -376,15 +380,33 @@ export function createTelegramTypingLoopStarter<TContext>(
   options?: { target?: TelegramTypingLoopTarget },
 ) => void {
   return (ctx, chatId, options) => {
+    const transportAuthority = deps.getTransportAuthority?.();
+    const hasTransport = (): boolean =>
+      deps.getTransportAuthority
+        ? transportAuthority !== undefined &&
+          Object.is(deps.getTransportAuthority(), transportAuthority)
+        : deps.isTransportAvailable?.() !== false;
+    if (!hasTransport()) return;
+    let active = true;
     deps.typing.start({
       chatId: chatId ?? deps.getDefaultChatId(),
       target: options?.target,
       intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
       sendTypingAction: async (targetChatId, actionOptions) => {
+        if (!active) return;
+        if (!hasTransport()) {
+          deps.typing.stop();
+          return;
+        }
         try {
           await deps.sendTypingAction(targetChatId, actionOptions);
         } 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, {
@@ -404,10 +426,20 @@ 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, {
@@ -427,6 +459,10 @@ export function createTelegramTypingLoopStarter<TContext>(
             }
           }
         : undefined,
+      shouldContinue: hasTransport,
+      onStopped: () => {
+        active = false;
+      },
     });
   };
 }
@@ -442,7 +478,12 @@ export function startTelegramTypingLoop(
 ): boolean {
   if (deps.chatId === undefined || deps.chatId === 0) return false;
   const previousKey = state.typingLoopKey;
+  const previousDeps = state.typingLoopDeps;
   const nextKey = getTelegramTypingLoopKey(deps);
+  if (previousDeps && previousDeps !== deps) {
+    previousDeps.onStopped?.();
+    state.typingInFlight = undefined;
+  }
   state.typingLoopDeps = deps;
   state.typingLoopKey = nextKey;
   const sendTyping = (): void => {
@@ -450,10 +491,14 @@ export function startTelegramTypingLoop(
     if (
       !activeDeps ||
       activeDeps.chatId === undefined ||
-      activeDeps.chatId === 0 ||
-      state.typingInFlight
+      activeDeps.chatId === 0
     )
       return;
+    if (activeDeps.shouldContinue?.() === false) {
+      stopTelegramTypingLoop(state);
+      return;
+    }
+    if (state.typingInFlight) return;
     const targetChatId = activeDeps.chatId;
     const threadParams = getTelegramTypingLoopThreadParams(activeDeps.target);
     const typing = Promise.resolve()
@@ -486,9 +531,12 @@ export function stopTelegramTypingLoop(
 ): boolean {
   if (!state.typingInterval) return false;
   clearInterval(state.typingInterval);
+  const activeDeps = state.typingLoopDeps;
   state.typingInterval = undefined;
   state.typingLoopDeps = undefined;
   state.typingLoopKey = undefined;
+  state.typingInFlight = undefined;
+  activeDeps?.onStopped?.();
   return true;
 }
 
@@ -571,6 +619,8 @@ export interface TelegramPromptDispatchRuntimeDeps<
   sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
   updateStatus: (ctx: TContext, error?: string) => void;
   isContextActive?: (ctx: TContext) => boolean;
+  isTransportAvailable?: () => boolean;
+  getTransportAuthority?: () => string | number | undefined;
   intervalMs?: number;
 }
 

package/package.json

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