@llblab/pi-telegram 0.10.3 → 0.10.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.10.5: Queue Continuity And Input Resilience Hotfix
+
+- `[Compaction]` `/compact` completion and failure callbacks now request deferred queue dispatch instead of dispatching immediately. Impact: queued Telegram turns resume after compaction state and π idle/pending-message state have a chance to settle.
+- `[Text Groups]` Long-text split recovery is more aggressive where Telegram chunking actually drifts: the debounce is rounded to 1s, the conservative 3600-character start threshold is preserved, and continuation messages can span a much wider message-id gap while staying scoped to the same chat/user and non-command text. Impact: very large pasted prompts are more likely to arrive as one agent turn instead of several fragmented turns.
+- `[Runtime Status]` Typing-loop and prompt-dispatch status updates are now best-effort and record stale-context failures as structured runtime events. Impact: status/Running indicators remain resilient after error paths without hiding diagnostics.
+- `[Tests]` Added regressions for deferred compact dispatch, stale status failures in typing/dispatch paths, and many-part split-text grouping.
+
+## 0.10.4: Polling Status Resilience Hotfix
+
+- `[Polling]` Status-bar updates from the polling loop are now best-effort and no longer crash the extension when a captured session context becomes stale after session reload. Failures are recorded as structured polling runtime events with `phase: "status-update"`. Impact: polling cleanup and retry status updates stay resilient without changing the Telegram API, config, or operator workflow.
+- `[Tests]` Added stale-context polling regressions for startup, cleanup, and retry status updates. Impact: the external PR #43 fix is now covered by maintainer-side tests and kept aligned with local style.
+
 ## 0.10.3: Dependency Audit Hotfix
 
 - `[Dependencies]` Refreshed the lockfile transitive dependency set to resolve current `protobufjs` / `@protobufjs/utf8` npm audit advisories inherited through development peer installs. Impact: `npm run validate` is green again without changing runtime API or bridge behavior.

package/README.md

@@ -240,9 +240,11 @@ Import from `@llblab/pi-telegram`, call `registerTelegramSection()`, and return
 
 Third-party extensions that integrate with `pi-telegram`:
 
-| Extension | Description | Install |
-|-----------|-------------|---------|
-| [`pi-telegram-tool-status`](https://github.com/Timur00Kh/pi-telegram-tool-status) | Live-updating service message listing tools used by the agent. One message per Telegram prompt, edited in-place as tools execute. | `pi install npm:pi-telegram-tool-status` |
+- [`pi-telegram-tool-status`](https://github.com/Timur00Kh/pi-telegram-tool-status) — Live-updating service messages that list tools used by the agent. It keeps one message per Telegram prompt and edits it in place as tools execute.
+
+```bash
+pi install npm:pi-telegram-tool-status
+```
 
 ## License
 

package/index.ts

@@ -352,6 +352,8 @@ export default function (pi: Pi.ExtensionAPI) {
     inboundHandlerRuntime,
     updateStatus,
     dispatchNextQueuedTelegramTurn,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deferredQueueDispatchRuntime.request,
     answerCallbackQuery,
     editInteractiveMessage,
     sendInteractiveMessage,

package/lib/commands.ts

@@ -317,6 +317,9 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
   setCompactionInProgress: (inProgress: boolean) => void;
   updateStatus: () => void;
   dispatchNextQueuedTelegramTurn: () => void;
+  requestDeferredDispatchNextQueuedTelegramTurn?: (
+    dispatch: () => void,
+  ) => void;
   compact: (callbacks: {
     onComplete: () => void;
     onError: (error: unknown) => void;
@@ -547,6 +550,9 @@ export interface TelegramCommandRuntimeDeps<
   setCompactionInProgress: (inProgress: boolean) => void;
   updateStatus: (ctx: TContext) => void;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  requestDeferredDispatchNextQueuedTelegramTurn?: (
+    dispatch: (ctx: TContext) => void,
+  ) => void;
   enqueueContinueTurn: (message: TMessage, ctx: TContext) => Promise<void>;
   compact: (
     ctx: TContext,
@@ -758,6 +764,22 @@ export async function handleTelegramContinueCommand<TMessage, TContext>(
   await deps.enqueueContinueTurn(message, ctx);
 }
 
+function dispatchNextQueuedTelegramTurnAfterCompact(
+  deps: Pick<
+    TelegramCompactCommandDeps,
+    | "dispatchNextQueuedTelegramTurn"
+    | "requestDeferredDispatchNextQueuedTelegramTurn"
+  >,
+): void {
+  if (deps.requestDeferredDispatchNextQueuedTelegramTurn) {
+    deps.requestDeferredDispatchNextQueuedTelegramTurn(
+      deps.dispatchNextQueuedTelegramTurn,
+    );
+    return;
+  }
+  deps.dispatchNextQueuedTelegramTurn();
+}
+
 export async function handleTelegramCompactCommand(
   deps: TelegramCompactCommandDeps,
 ): Promise<void> {
@@ -781,13 +803,13 @@ export async function handleTelegramCompactCommand(
       onComplete: () => {
         deps.setCompactionInProgress(false);
         deps.updateStatus();
-        deps.dispatchNextQueuedTelegramTurn();
+        dispatchNextQueuedTelegramTurnAfterCompact(deps);
         void deps.sendTextReply("Compaction completed.");
       },
       onError: (error) => {
         deps.setCompactionInProgress(false);
         deps.updateStatus();
-        deps.dispatchNextQueuedTelegramTurn();
+        dispatchNextQueuedTelegramTurnAfterCompact(deps);
         deps.recordRuntimeEvent?.("compact", error);
         const errorMessage = getTelegramCommandErrorMessage(error);
         void deps.sendTextReply(`Compaction failed: ${errorMessage}`);
@@ -1069,6 +1091,13 @@ async function handleTelegramCommandRuntime<
           updateStatus: updateStatusFor(commandCtx),
           dispatchNextQueuedTelegramTurn: () =>
             deps.dispatchNextQueuedTelegramTurn(commandCtx),
+          requestDeferredDispatchNextQueuedTelegramTurn:
+            deps.requestDeferredDispatchNextQueuedTelegramTurn
+              ? (dispatch) =>
+                  deps.requestDeferredDispatchNextQueuedTelegramTurn?.(() =>
+                    dispatch(),
+                  )
+              : undefined,
           compact: (callbacks) => deps.compact(commandCtx, callbacks),
           sendTextReply: sendReplyFor(nextMessage),
           recordRuntimeEvent: deps.recordRuntimeEvent,

package/lib/polling.ts

@@ -91,7 +91,8 @@ export function createTelegramPollingActivityReader(
   return () => isTelegramPollingControllerActive(state);
 }
 
-export interface TelegramPollingRuntimeDeps<TContext> {
+export interface TelegramPollingRuntimeDeps<TContext>
+  extends TelegramRuntimeEventRecorderPort {
   hasBotToken: () => boolean;
   getPollingPromise: () => Promise<void> | undefined;
   setPollingPromise: (promise: Promise<void> | undefined) => void;
@@ -150,6 +151,7 @@ export function createTelegramPollingControllerRuntime<
     }),
     updateStatus: deps.updateStatus,
     createAbortController: deps.createAbortController,
+    recordRuntimeEvent: deps.recordRuntimeEvent,
   });
 }
 
@@ -191,6 +193,22 @@ export async function stopTelegramPollingRuntime<TContext>(
   deps.setPollingPromise(undefined);
 }
 
+function updateTelegramPollingStatusSafely<TContext>(
+  updateStatus: (ctx: TContext, message?: string) => void,
+  ctx: TContext,
+  options: {
+    message?: string;
+    recordRuntimeEvent?: TelegramRuntimeEventRecorderPort["recordRuntimeEvent"];
+  } = {},
+): void {
+  try {
+    updateStatus(ctx, options.message);
+  } catch (error) {
+    // The polling loop can outlive the session context it captured.
+    options.recordRuntimeEvent?.("polling", error, { phase: "status-update" });
+  }
+}
+
 export function startTelegramPollingRuntime<TContext>(
   ctx: TContext,
   deps: TelegramPollingRuntimeDeps<TContext>,
@@ -208,10 +226,14 @@ export function startTelegramPollingRuntime<TContext>(
   const promise = deps.runPollLoop(ctx, controller.signal).finally(() => {
     deps.setPollingPromise(undefined);
     deps.setPollingController(undefined);
-    deps.updateStatus(ctx);
+    updateTelegramPollingStatusSafely(deps.updateStatus, ctx, {
+      recordRuntimeEvent: deps.recordRuntimeEvent,
+    });
   });
   deps.setPollingPromise(promise);
-  deps.updateStatus(ctx);
+  updateTelegramPollingStatusSafely(deps.updateStatus, ctx, {
+    recordRuntimeEvent: deps.recordRuntimeEvent,
+  });
 }
 
 export interface TelegramRuntimeEventRecorderPort {
@@ -281,10 +303,15 @@ export function createTelegramPollLoopRunner<
       persistConfig: deps.persistConfig,
       handleUpdate: deps.handleUpdate,
       onErrorStatus: (message) => {
-        deps.updateStatus(ctx, message);
+        updateTelegramPollingStatusSafely(deps.updateStatus, ctx, {
+          message,
+          recordRuntimeEvent: deps.recordRuntimeEvent,
+        });
       },
       onStatusReset: () => {
-        deps.updateStatus(ctx);
+        updateTelegramPollingStatusSafely(deps.updateStatus, ctx, {
+          recordRuntimeEvent: deps.recordRuntimeEvent,
+        });
       },
       sleep,
       maxUpdateFailures: deps.maxUpdateFailures,

package/lib/routing.ts

@@ -79,6 +79,9 @@ export interface TelegramInboundRouteRuntimeDeps<
   inboundHandlerRuntime: TelegramInboundHandlerRuntime<TContext>;
   updateStatus: (ctx: TContext, error?: string) => void;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  requestDeferredDispatchNextQueuedTelegramTurn?: (
+    dispatch: (ctx: TContext) => void,
+  ) => void;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -339,6 +342,8 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.setCompactionInProgress,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deps.requestDeferredDispatchNextQueuedTelegramTurn,
     enqueueContinueTurn,
     compact: deps.compact,
     allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,

package/lib/runtime.ts

@@ -328,6 +328,25 @@ export interface TelegramRuntimeEventRecorderPort {
   ) => void;
 }
 
+function updateTelegramRuntimeStatusSafely<TContext>(
+  updateStatus: (ctx: TContext, error?: string) => void,
+  ctx: TContext,
+  options: {
+    error?: string;
+    category: string;
+    phase: string;
+    recordRuntimeEvent?: TelegramRuntimeEventRecorderPort["recordRuntimeEvent"];
+  },
+): void {
+  try {
+    updateStatus(ctx, options.error);
+  } catch (statusError) {
+    options.recordRuntimeEvent?.(options.category, statusError, {
+      phase: options.phase,
+    });
+  }
+}
+
 export interface TelegramTypingLoopStarterDeps<
   TContext,
 > extends TelegramRuntimeEventRecorderPort {
@@ -351,7 +370,12 @@ export function createTelegramTypingLoopStarter<TContext>(
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
-          deps.updateStatus(ctx, message);
+          updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
+            error: message,
+            category: "typing",
+            phase: "status-update",
+            recordRuntimeEvent: deps.recordRuntimeEvent,
+          });
           deps.recordRuntimeEvent?.("typing", error, {
             chatId: targetChatId,
           });
@@ -468,13 +492,22 @@ export function createTelegramPromptDispatchLifecycle<TContext>(
     onPromptDispatchStart: (ctx: TContext, chatId?: number): void => {
       deps.lifecycle.setDispatchPending(true);
       deps.startTypingLoop(ctx, chatId);
-      deps.updateStatus(ctx);
+      updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
+        category: "dispatch",
+        phase: "status-update",
+        recordRuntimeEvent: deps.recordRuntimeEvent,
+      });
     },
     onPromptDispatchFailure: (ctx: TContext, message: string): void => {
       deps.lifecycle.clearDispatchPending();
       deps.typing.stop();
       deps.recordRuntimeEvent?.("dispatch", new Error(message));
-      deps.updateStatus(ctx, `dispatch failed: ${message}`);
+      updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
+        error: `dispatch failed: ${message}`,
+        category: "dispatch",
+        phase: "status-update",
+        recordRuntimeEvent: deps.recordRuntimeEvent,
+      });
     },
   };
 }

package/lib/text-groups.ts

@@ -4,8 +4,9 @@
  * Owns conservative delayed grouping for Telegram text messages that look like automatic long-message splits
  */
 
-const TELEGRAM_TEXT_GROUP_DEBOUNCE_MS = 700;
+const TELEGRAM_TEXT_GROUP_DEBOUNCE_MS = 1000;
 const TELEGRAM_TEXT_GROUP_MIN_SPLIT_LENGTH = 3600;
+const TELEGRAM_TEXT_GROUP_MAX_MESSAGE_ID_GAP = 10;
 
 export interface TelegramTextGroupMessage {
   message_id: number;
@@ -91,7 +92,7 @@ function canAppendTelegramTextGroupMessage<
   return (
     !!previous &&
     message.message_id > previous.message_id &&
-    message.message_id <= previous.message_id + 2 &&
+    message.message_id <= previous.message_id + TELEGRAM_TEXT_GROUP_MAX_MESSAGE_ID_GAP &&
     text.length > 0 &&
     !isTelegramTextGroupCommand(text)
   );

package/package.json

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