@llblab/pi-telegram 0.10.5 → 0.10.7

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.10.7: Stale Context Hardening Hotfix
+
+- `[Session Reloads]` Context-sensitive command, pairing, queue, session-start, and update-dispatch paths now ignore only stale-session/stale-context failures instead of swallowing broad runtime errors. Impact: the bridge survives ctx replacement/fork/reload races while real bugs still surface for diagnostics.
+- `[Runtime Status]` Restored status update error propagation so existing polling/dispatch safety wrappers can record stale status failures as structured runtime events instead of losing diagnostics inside the status domain.
+- `[Release]` Added a tag-triggered GitHub Actions release workflow that verifies the `vX.Y.Z` tag matches `package.json`, extracts the matching `CHANGELOG.md` section, and publishes a GitHub Release automatically.
+- `[Tests]` Added focused regressions proving the newly guarded call sites tolerate stale context errors and still rethrow unrelated failures.
+
+## 0.10.6: Native Typing Keepalive Hotfix
+
+- `[Typing]` Telegram native `typing` chat actions now refresh every 2.5s instead of every 4s. Impact: the bot's Telegram-side typing animation has more headroom to stay visible during model retries, transient model/API errors, and other long-running agent work.
+- `[Queue Menu]` Empty queue refresh now rotates through a wider set of small status phrases. Impact: repeatedly refreshing an empty queue feels less repetitive while preserving the same callbacks and menu layout.
+- `[Tests]` Added coverage for the default native typing keepalive cadence.
+
 ## 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.

package/lib/commands.ts

@@ -579,7 +579,7 @@ export interface TelegramCommandRuntimeDeps<
 }
 
 export const TELEGRAM_APP_MENU_INTRO_HTML = [
-  "<b>π Telegram bridge</b>",
+  "<b>π Telegram</b>",
   "",
   `${formatTelegramCommandEmojiPrefix("start")}/start — Open menu / Pair bridge`,
   `${formatTelegramCommandEmojiPrefix("compact")}/compact — Compact current session`,
@@ -826,18 +826,34 @@ export async function handleTelegramCompactCommand(
   await deps.sendTextReply("Compaction started.");
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export async function handleTelegramStatusCommand<TContext>(deps: {
   ctx: TContext;
   showStatus: (ctx: TContext) => Promise<void>;
 }): Promise<void> {
-  await deps.showStatus(deps.ctx);
+  try {
+    await deps.showStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export async function handleTelegramModelCommand<TContext>(deps: {
   ctx: TContext;
   openModelMenu: (ctx: TContext) => Promise<void>;
 }): Promise<void> {
-  await deps.openModelMenu(deps.ctx);
+  try {
+    await deps.openModelMenu(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export async function executeTelegramCommandAction<TMessage, TContext>(

package/lib/config.ts

@@ -185,6 +185,14 @@ export function getTelegramAuthorizationState(
   return { kind: "deny" };
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export async function pairTelegramUserIfNeeded<TContext>(
   userId: number,
   deps: TelegramUserPairingDeps<TContext>,
@@ -196,7 +204,11 @@ export async function pairTelegramUserIfNeeded<TContext>(
   if (authorization.kind !== "pair") return false;
   deps.setAllowedUserId(authorization.userId);
   await deps.persistConfig();
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return true;
 }
 

package/lib/menu-queue.ts

@@ -18,6 +18,14 @@ const EMPTY_QUEUE_REFRESH_TITLES = [
   "<b>🫙 Still nothing in queue.</b>",
   "<b>🍃 Queue remains empty.</b>",
   "<b>🕳 Nothing queued yet.</b>",
+  "<b>🦗 Queue crickets continue.</b>",
+  "<b>🌙 Queue is peacefully idle.</b>",
+  "<b>🧘 Nothing waiting. Very zen.</b>",
+  "<b>🪐 Queue orbit is clear.</b>",
+  "<b>🧺 Basket is empty.</b>",
+  "<b>🔭 No prompts on the horizon.</b>",
+  "<b>🫧 Queue bubbles: none.</b>",
+  "<b>🛸 No queued signals detected.</b>",
 ] as const;
 type TelegramQueueMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 interface TelegramQueueMenuItem {

package/lib/queue.ts

@@ -1289,6 +1289,14 @@ export interface TelegramPromptEnqueueController<TMessage, TContext = unknown> {
   enqueue: (messages: TMessage[], ctx: TContext) => Promise<void>;
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export function buildTelegramSessionStartState<TModel = unknown>(
   currentModel: TModel | undefined,
 ): TelegramSessionStartState<TModel> {
@@ -1326,7 +1334,11 @@ export async function startTelegramSessionRuntime<TContext, TModel = unknown>(
   await deps.loadConfig();
   deps.applyState(buildTelegramSessionStartState(deps.currentModel));
   await deps.prepareTempDir();
-  deps.bindDeferredDispatchContext?.(deps.ctx);
+  try {
+    deps.bindDeferredDispatchContext?.(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   deps.updateStatus();
 }
 
@@ -1478,7 +1490,11 @@ export function reorderTelegramQueueItemsRuntime<TContext>(
   deps.setQueuedItems(
     [...deps.getQueuedItems()].sort(compareTelegramQueueItems),
   );
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export function clearTelegramQueueItemsRuntime<TContext>(
@@ -1487,7 +1503,11 @@ export function clearTelegramQueueItemsRuntime<TContext>(
   const removedCount = deps.getQueuedItems().length;
   if (removedCount === 0) return 0;
   deps.setQueuedItems([]);
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return removedCount;
 }
 
@@ -1501,7 +1521,11 @@ export function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(
   );
   if (removedCount === 0) return 0;
   deps.setQueuedItems(items);
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return removedCount;
 }
 

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 = 4000;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
 
 export interface TelegramRuntimeQueueCounters {
   nextQueuedTelegramItemOrder: number;

package/lib/updates.ts

@@ -746,6 +746,14 @@ export async function handleAuthorizedTelegramReactionUpdate<TContext>(
   );
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export async function executeTelegramUpdatePlan<
   TContext = unknown,
   TReactionUpdate extends TelegramMessageReactionUpdated =
@@ -761,81 +769,85 @@ export async function executeTelegramUpdatePlan<
     TMessage
   >,
 ): Promise<void> {
-  if (plan.kind === "ignore") return;
-  if (plan.kind === "deleted") {
-    deps.removePendingMediaGroupMessages(plan.messageIds);
-    deps.removeQueuedTelegramTurnsByMessageIds(plan.messageIds, deps.ctx);
-    return;
-  }
-  if (plan.kind === "reaction") {
-    await deps.handleAuthorizedTelegramReactionUpdate(
-      plan.reactionUpdate,
-      deps.ctx,
-    );
-    return;
-  }
-  if (plan.kind === "callback") {
-    if (plan.shouldPair) {
-      await deps.pairTelegramUserIfNeeded(plan.query.from.id, deps.ctx);
-    }
-    if (plan.shouldDeny) {
-      const callbackQueryId = getTelegramCallbackQueryId(plan.query);
-      if (callbackQueryId) {
-        await deps.answerCallbackQuery(
-          callbackQueryId,
-          "This bot is not authorized for your account.",
-        );
-      }
+  try {
+    if (plan.kind === "ignore") return;
+    if (plan.kind === "deleted") {
+      deps.removePendingMediaGroupMessages(plan.messageIds);
+      deps.removeQueuedTelegramTurnsByMessageIds(plan.messageIds, deps.ctx);
       return;
     }
-    await deps.handleAuthorizedTelegramCallbackQuery(plan.query, deps.ctx);
-    return;
-  }
-  if (plan.kind === "guest") {
-    if (plan.shouldDeny) {
-      await deps.answerGuestQuery(
-        plan.guestMessage.guest_query_id,
-        "Access denied.",
+    if (plan.kind === "reaction") {
+      await deps.handleAuthorizedTelegramReactionUpdate(
+        plan.reactionUpdate,
+        deps.ctx,
       );
       return;
     }
-    if (deps.handleAuthorizedTelegramGuestMessage) {
-      await deps.handleAuthorizedTelegramGuestMessage(
-        plan.guestMessage,
-        deps.ctx,
-      );
+    if (plan.kind === "callback") {
+      if (plan.shouldPair) {
+        await deps.pairTelegramUserIfNeeded(plan.query.from.id, deps.ctx);
+      }
+      if (plan.shouldDeny) {
+        const callbackQueryId = getTelegramCallbackQueryId(plan.query);
+        if (callbackQueryId) {
+          await deps.answerCallbackQuery(
+            callbackQueryId,
+            "This bot is not authorized for your account.",
+          );
+        }
+        return;
+      }
+      await deps.handleAuthorizedTelegramCallbackQuery(plan.query, deps.ctx);
+      return;
     }
-    return;
-  }
-  const pairedNow = plan.shouldPair
-    ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
-    : false;
-  const replyTarget = getTelegramMessageReplyTarget(plan.message);
-  if (
-    plan.kind === "message" &&
-    pairedNow &&
-    plan.shouldNotifyPaired &&
-    replyTarget
-  ) {
-    await deps.sendTextReply(
-      replyTarget.chatId,
-      replyTarget.messageId,
-      "Telegram bridge paired with this account.",
-    );
-  }
-  if (plan.shouldDeny) {
-    if (replyTarget) {
+    if (plan.kind === "guest") {
+      if (plan.shouldDeny) {
+        await deps.answerGuestQuery(
+          plan.guestMessage.guest_query_id,
+          "Access denied.",
+        );
+        return;
+      }
+      if (deps.handleAuthorizedTelegramGuestMessage) {
+        await deps.handleAuthorizedTelegramGuestMessage(
+          plan.guestMessage,
+          deps.ctx,
+        );
+      }
+      return;
+    }
+    const pairedNow = plan.shouldPair
+      ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
+      : false;
+    const replyTarget = getTelegramMessageReplyTarget(plan.message);
+    if (
+      plan.kind === "message" &&
+      pairedNow &&
+      plan.shouldNotifyPaired &&
+      replyTarget
+    ) {
       await deps.sendTextReply(
         replyTarget.chatId,
         replyTarget.messageId,
-        "This bot is not authorized for your account.",
+        "Telegram bridge paired with this account.",
       );
     }
-    return;
-  }
-  if (plan.kind === "edited-message") {
-    await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
-    return;
+    if (plan.shouldDeny) {
+      if (replyTarget) {
+        await deps.sendTextReply(
+          replyTarget.chatId,
+          replyTarget.messageId,
+          "This bot is not authorized for your account.",
+        );
+      }
+      return;
+    }
+    if (plan.kind === "edited-message") {
+      await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
+      return;
+    }
+    await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
   }
-  await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
 }

package/package.json

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