@llblab/pi-telegram 0.11.2 → 0.12.0

package/lib/bindings.ts

@@ -0,0 +1,301 @@
+/**
+ * Telegram bridge binding composition
+ * Zones: telegram, pi agent, orchestration
+ * Owns pi-facing tool, command, and lifecycle hook registration for the entrypoint
+ */
+
+import * as Api from "./api.ts";
+import * as CommandTemplates from "./command-templates.ts";
+import * as Commands from "./commands.ts";
+import * as Config from "./config.ts";
+import * as Keyboard from "./keyboard.ts";
+import * as Lifecycle from "./lifecycle.ts";
+import * as Locks from "./locks.ts";
+import * as Model from "./model.ts";
+import * as OutboundAttachments from "./outbound-attachments.ts";
+import * as OutboundHandlers from "./outbound.ts";
+import * as Pi from "./pi.ts";
+import * as Preview from "./preview.ts";
+import * as Prompts from "./prompts.ts";
+import * as Queue from "./queue.ts";
+import * as Replies from "./replies.ts";
+import * as Runtime from "./runtime.ts";
+import * as Setup from "./setup.ts";
+import * as Status from "./status.ts";
+
+type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
+
+type TelegramRuntimeEventRecorder = (
+  category: string,
+  error: unknown,
+  details?: Record<string, unknown>,
+) => void;
+
+type TelegramBridgeStatusUpdater =
+  Status.TelegramStatusRuntime<Pi.ExtensionContext>["updateStatus"];
+
+interface TelegramCommandsAndToolsBindingDeps {
+  pi: Pi.ExtensionAPI;
+  configStore: Config.TelegramConfigStore;
+  setup: Setup.TelegramSetupGuard;
+  activeTurnRuntime: Queue.TelegramActiveTurnStore<Queue.PendingTelegramTurn>;
+  lockedPollingRuntime: Locks.TelegramLockedPollingRuntime<Pi.ExtensionContext>;
+  getStatusLines: () => string[];
+  updateStatus: TelegramBridgeStatusUpdater;
+  recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}
+
+export function registerTelegramCommandsAndTools({
+  pi,
+  configStore,
+  setup,
+  activeTurnRuntime,
+  lockedPollingRuntime,
+  getStatusLines,
+  updateStatus,
+  recordRuntimeEvent,
+}: TelegramCommandsAndToolsBindingDeps): void {
+  OutboundAttachments.registerTelegramOutboundAttachmentTool(pi, {
+    getActiveTurn: activeTurnRuntime.get,
+    recordRuntimeEvent,
+  });
+
+  Commands.registerTelegramBridgeCommands(pi, {
+    promptForConfig: Setup.createTelegramSetupPromptRuntime({
+      getConfig: configStore.get,
+      setConfig: configStore.set,
+      setupGuard: setup,
+      getMe: Api.fetchTelegramBotIdentity,
+      persistConfig: configStore.persist,
+      startPolling: lockedPollingRuntime.start,
+      updateStatus,
+      recordRuntimeEvent,
+    }),
+    getStatusLines,
+    reloadConfig: configStore.load,
+    hasBotToken: configStore.hasBotToken,
+    startPolling: lockedPollingRuntime.start,
+    stopPolling: lockedPollingRuntime.stop,
+    updateStatus,
+  });
+}
+
+interface TelegramLifecycleBindingDeps {
+  pi: Pi.ExtensionAPI;
+  sessionLifecycleRuntime: Pick<
+    Lifecycle.TelegramLifecycleRegistrationDeps,
+    "onSessionStart" | "onSessionShutdown" | "onModelSelect"
+  >;
+  queueSessionLifecycle: Pick<
+    Lifecycle.TelegramLifecycleRegistrationDeps,
+    "onSessionShutdown"
+  >;
+  configStore: Pick<Config.TelegramConfigStore, "getOutboundHandlers">;
+  abort: Runtime.TelegramRuntimeAbortPort;
+  typing: Runtime.TelegramRuntimeTypingPort;
+  lifecycle: Runtime.TelegramRuntimeLifecyclePort;
+  activeTurnRuntime: Queue.TelegramActiveTurnStore<Queue.PendingTelegramTurn>;
+  telegramQueueStore: Queue.TelegramQueueStore<Pi.ExtensionContext>;
+  modelSwitchController: Model.TelegramModelSwitchController<
+    Pi.ExtensionContext,
+    Model.ScopedTelegramModel<ActivePiModel>
+  >;
+  previewRuntime: Preview.TelegramAssistantPreviewRuntime<
+    Pi.AgentEndEvent["messages"][number],
+    Keyboard.TelegramInlineKeyboardMarkup
+  >;
+  promptDispatchRuntime: Runtime.TelegramPromptDispatchRuntime<Pi.ExtensionContext>;
+  deferredQueueDispatchRuntime: Queue.TelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>;
+  lockOwnershipGuard: Pick<
+    Locks.TelegramLockOwnershipGuard<Pi.ExtensionContext>,
+    "ownsContext"
+  >;
+  buttonActionStore: OutboundHandlers.TelegramButtonActionStore;
+  callMultipart: OutboundHandlers.TelegramVoiceReplySenderDeps["sendMultipart"];
+  sendChatAction: NonNullable<
+    OutboundHandlers.TelegramVoiceReplySenderDeps["sendChatAction"]
+  >;
+  sendRecordVoiceAction: NonNullable<
+    OutboundHandlers.TelegramVoiceReplySenderDeps["sendRecordVoiceAction"]
+  >;
+  sendMarkdownReply: Queue.TelegramAgentEndHookRuntimeDeps<
+    Queue.PendingTelegramTurn,
+    Pi.ExtensionContext,
+    Pi.AgentEndEvent["messages"][number],
+    Keyboard.TelegramInlineKeyboardMarkup
+  >["sendMarkdownReply"];
+  sendTextReply: Queue.TelegramAgentEndHookRuntimeDeps<
+    Queue.PendingTelegramTurn,
+    Pi.ExtensionContext,
+    Pi.AgentEndEvent["messages"][number],
+    Keyboard.TelegramInlineKeyboardMarkup
+  >["sendTextReply"] &
+    NonNullable<OutboundHandlers.TelegramVoiceReplySenderDeps["sendTextReply"]>;
+  dispatchNextQueuedTelegramTurn: (ctx: Pi.ExtensionContext) => void;
+  answerGuestQuery: NonNullable<
+    Queue.TelegramAgentEndHookRuntimeDeps<
+      Queue.PendingTelegramTurn,
+      Pi.ExtensionContext,
+      Pi.AgentEndEvent["messages"][number],
+      Keyboard.TelegramInlineKeyboardMarkup
+    >["answerGuestQuery"]
+  >;
+  sendGuestReply: NonNullable<
+    Queue.TelegramAgentEndHookRuntimeDeps<
+      Queue.PendingTelegramTurn,
+      Pi.ExtensionContext,
+      Pi.AgentEndEvent["messages"][number],
+      Keyboard.TelegramInlineKeyboardMarkup
+    >["sendGuestReply"]
+  >;
+  finalizeMarkdownPreview: Queue.TelegramAgentEndHookRuntimeDeps<
+    Queue.PendingTelegramTurn,
+    Pi.ExtensionContext,
+    Pi.AgentEndEvent["messages"][number],
+    Keyboard.TelegramInlineKeyboardMarkup
+  >["finalizeMarkdownPreview"];
+  proactivePushChatIdGetter: () => number | undefined;
+  isProactivePushEnabled: () => boolean;
+  updateStatus: TelegramBridgeStatusUpdater;
+  recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}
+
+export function registerTelegramLifecycleRuntimeHooks({
+  pi,
+  sessionLifecycleRuntime,
+  queueSessionLifecycle,
+  configStore,
+  abort,
+  typing,
+  lifecycle,
+  activeTurnRuntime,
+  telegramQueueStore,
+  modelSwitchController,
+  previewRuntime,
+  promptDispatchRuntime,
+  deferredQueueDispatchRuntime,
+  lockOwnershipGuard,
+  buttonActionStore,
+  callMultipart,
+  sendChatAction,
+  sendRecordVoiceAction,
+  sendMarkdownReply,
+  sendTextReply,
+  dispatchNextQueuedTelegramTurn,
+  answerGuestQuery,
+  sendGuestReply,
+  finalizeMarkdownPreview,
+  proactivePushChatIdGetter,
+  isProactivePushEnabled,
+  updateStatus,
+  recordRuntimeEvent,
+}: TelegramLifecycleBindingDeps): void {
+  const agentEndResetter = Runtime.createTelegramAgentEndResetter({
+    abort,
+    typing,
+    clearActiveTurn: activeTurnRuntime.clear,
+    resetToolExecutions: lifecycle.resetActiveToolExecutions,
+    clearPendingModelSwitch: modelSwitchController.clearPendingSwitch,
+    clearDispatchPending: lifecycle.clearDispatchPending,
+  });
+  const queuedAttachmentSender =
+    OutboundAttachments.createTelegramQueuedOutboundAttachmentSender({
+      sendMultipart: callMultipart,
+      sendTextReply,
+      recordRuntimeEvent,
+    });
+  const outboundReplyPlanner =
+    OutboundHandlers.createTelegramOutboundReplyPlanner(buttonActionStore);
+  const outboundReplyArtifactSender =
+    OutboundHandlers.createTelegramOutboundReplyArtifactSender({
+      execCommand: CommandTemplates.execCommandTemplate,
+      sendMultipart: callMultipart,
+      sendTextReply,
+      sendChatAction,
+      sendRecordVoiceAction,
+      getHandlers: configStore.getOutboundHandlers,
+      recordRuntimeEvent,
+    });
+  const agentLifecycleHooks = Queue.createTelegramAgentLifecycleHooks<
+    Queue.PendingTelegramTurn,
+    Pi.ExtensionContext,
+    unknown,
+    Keyboard.TelegramInlineKeyboardMarkup
+  >({
+    setAbortHandler: Runtime.createTelegramContextAbortHandlerSetter(abort),
+    getQueuedItems: telegramQueueStore.getQueuedItems,
+    hasPendingDispatch: lifecycle.hasDispatchPending,
+    hasActiveTurn: activeTurnRuntime.has,
+    resetToolExecutions: lifecycle.resetActiveToolExecutions,
+    resetPendingModelSwitch: modelSwitchController.clearPendingSwitch,
+    setQueuedItems: telegramQueueStore.setQueuedItems,
+    clearDispatchPending: lifecycle.clearDispatchPending,
+    setActiveTurn: activeTurnRuntime.set,
+    createPreviewState: previewRuntime.resetState,
+    startTypingLoop: promptDispatchRuntime.startTypingLoop,
+    updateStatus,
+    getActiveTurn: activeTurnRuntime.get,
+    extractAssistant: Replies.extractLatestAssistantMessageText,
+    getPreserveQueuedTurnsAsHistory:
+      lifecycle.shouldPreserveQueuedTurnsAsHistory,
+    resetRuntimeState: agentEndResetter,
+    dispatchNextQueuedTelegramTurn,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deferredQueueDispatchRuntime.request,
+    clearPreview: previewRuntime.clear,
+    setPreviewPendingText: previewRuntime.setPendingText,
+    finalizeMarkdownPreview,
+    sendMarkdownReply,
+    sendTextReply,
+    sendQueuedAttachments: queuedAttachmentSender,
+    answerGuestQuery,
+    sendGuestReply,
+    planOutboundReply: outboundReplyPlanner,
+    sendOutboundReplyArtifacts: outboundReplyArtifactSender,
+    isCurrentOwner: lockOwnershipGuard.ownsContext,
+    getDefaultChatId: proactivePushChatIdGetter,
+    isProactivePushEnabled,
+    recordRuntimeEvent,
+    getActiveToolExecutions: lifecycle.getActiveToolExecutions,
+    setActiveToolExecutions: lifecycle.setActiveToolExecutions,
+    triggerPendingModelSwitchAbort: modelSwitchController.triggerPendingAbort,
+  });
+
+  Lifecycle.setResetTransportReplyDedup(Replies.resetTransportReplyDedup);
+  const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
+    agentLifecycleHooks.onAgentStart,
+  );
+  const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
+    setCompactionInProgress: lifecycle.setCompactionInProgress,
+    updateStatus,
+    startTypingLoop: promptDispatchRuntime.startTypingLoop,
+    stopTypingLoop: typing.stop,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deferredQueueDispatchRuntime.request,
+    dispatchNextQueuedTelegramTurn,
+    recordRuntimeEvent,
+  });
+  const messageActivityTypingHooks =
+    Lifecycle.createTelegramMessageActivityTypingHooks({
+      hasActiveTurn: activeTurnRuntime.has,
+      startTypingLoop: promptDispatchRuntime.startTypingLoop,
+      onMessageStart: previewRuntime.onMessageStart,
+      onMessageUpdate: previewRuntime.onMessageUpdate,
+    });
+  Lifecycle.registerTelegramLifecycleHooks(pi, {
+    ...sessionLifecycleRuntime,
+    ...agentLifecycleHooks,
+    async onSessionShutdown(event, ctx) {
+      compactionObserver.onSessionShutdown();
+      await queueSessionLifecycle.onSessionShutdown(event, ctx);
+    },
+    onSessionBeforeCompact: compactionObserver.onSessionBeforeCompact,
+    onSessionCompact: compactionObserver.onSessionCompact,
+    onAgentStart: agentStartWithDedupReset,
+    onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({
+      isProactivePushEnabled,
+      isCurrentOwner: lockOwnershipGuard.ownsContext,
+    }),
+    ...messageActivityTypingHooks,
+  });
+}

package/lib/commands.ts

@@ -307,6 +307,10 @@ export interface TelegramRuntimeEventRecorderPort {
   ) => void;
 }
 
+export interface TelegramCompactConfirmationReplyMarkup {
+  inline_keyboard: { text: string; callback_data: string }[][];
+}
+
 export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorderPort {
   isIdle: () => boolean;
   hasPendingMessages: () => boolean;
@@ -327,6 +331,42 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
     onError: (error: unknown) => void;
   }) => void;
   sendTextReply: (text: string) => Promise<void>;
+  suppressStartNotice?: boolean;
+}
+
+export interface TelegramCompactConfirmationDeps {
+  sendInteractiveMessage: (
+    chatId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramCompactConfirmationReplyMarkup,
+  ) => Promise<number | undefined>;
+}
+
+export interface TelegramCompactConfirmationCallbackQuery {
+  id: string;
+  data?: string;
+  message?: { chat?: { id?: number }; message_id?: number };
+}
+
+export interface TelegramCompactConfirmationCallbackDeps<TContext> {
+  ctx: TContext;
+  answerCallbackQuery: (
+    callbackQueryId: string,
+    text?: string,
+  ) => Promise<void>;
+  editInteractiveMessage: (
+    chatId: number,
+    messageId: number,
+    text: string,
+    mode: "html" | "plain",
+    replyMarkup: TelegramCompactConfirmationReplyMarkup,
+  ) => Promise<void>;
+  runCompact: (
+    ctx: TContext,
+    chatId: number,
+    replyToMessageId: number,
+  ) => Promise<void>;
 }
 
 export type TelegramControlCommandType =
@@ -580,6 +620,7 @@ export interface TelegramCommandRuntimeDeps<
   getPromptTemplateCommands?: () => readonly TelegramPromptTemplateMenuCommand[];
   persistConfig: () => Promise<void>;
   sendTextReply: (message: TMessage, text: string) => Promise<void>;
+  sendInteractiveMessage?: TelegramCompactConfirmationDeps["sendInteractiveMessage"];
 }
 
 export const TELEGRAM_APP_MENU_INTRO_HTML = [
@@ -784,6 +825,69 @@ function dispatchNextQueuedTelegramTurnAfterCompact(
   deps.dispatchNextQueuedTelegramTurn();
 }
 
+export function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
+  return {
+    inline_keyboard: [
+      [
+        { text: "🗜 Yes, compact", callback_data: "compact:confirm" },
+        { text: "❌ No", callback_data: "compact:cancel" },
+      ],
+    ],
+  };
+}
+
+export function getTelegramCompactConfirmationHtml(): string {
+  return "<b>Compact session?</b>";
+}
+
+export async function openTelegramCompactConfirmation(
+  chatId: number,
+  deps: TelegramCompactConfirmationDeps,
+): Promise<void> {
+  await deps.sendInteractiveMessage(
+    chatId,
+    getTelegramCompactConfirmationHtml(),
+    "html",
+    buildTelegramCompactConfirmationReplyMarkup(),
+  );
+}
+
+export async function handleTelegramCompactConfirmationCallback<TContext>(
+  query: TelegramCompactConfirmationCallbackQuery,
+  deps: TelegramCompactConfirmationCallbackDeps<TContext>,
+): Promise<boolean> {
+  if (query.data !== "compact:confirm" && query.data !== "compact:cancel") {
+    return false;
+  }
+  const chatId = query.message?.chat?.id;
+  const messageId = query.message?.message_id;
+  if (typeof chatId !== "number" || typeof messageId !== "number") {
+    await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+    return true;
+  }
+  if (query.data === "compact:cancel") {
+    await deps.editInteractiveMessage(
+      chatId,
+      messageId,
+      "Compaction cancelled.",
+      "plain",
+      { inline_keyboard: [] },
+    );
+    await deps.answerCallbackQuery(query.id);
+    return true;
+  }
+  await deps.editInteractiveMessage(
+    chatId,
+    messageId,
+    "Compaction started.",
+    "plain",
+    { inline_keyboard: [] },
+  );
+  await deps.answerCallbackQuery(query.id);
+  await deps.runCompact(deps.ctx, chatId, messageId);
+  return true;
+}
+
 export async function handleTelegramCompactCommand(
   deps: TelegramCompactCommandDeps,
 ): Promise<void> {
@@ -834,7 +938,9 @@ export async function handleTelegramCompactCommand(
     await deps.sendTextReply(`Compaction failed: ${errorMessage}`);
     return;
   }
-  await deps.sendTextReply("Compaction started.");
+  if (!deps.suppressStartNotice) {
+    await deps.sendTextReply("Compaction started.");
+  }
   if (compactionStillInProgress) deps.startTypingLoop?.();
 }
 
@@ -978,6 +1084,7 @@ export function createTelegramCommandHandlerTargetRuntime<
     stopTypingLoop: deps.stopTypingLoop,
     enqueueContinueTurn: deps.enqueueContinueTurn,
     compact: deps.compact,
+    sendInteractiveMessage: deps.sendInteractiveMessage,
     enqueueControlItem: commandTargetRuntime.enqueueControlItem,
     showStatus: commandTargetRuntime.showStatus,
     openModelMenu: commandTargetRuntime.openModelMenu,
@@ -1110,6 +1217,12 @@ async function handleTelegramCommandRuntime<
         await deps.openQueueMenu(nextMessage, commandCtx);
       },
       handleCompact: async (nextMessage, commandCtx) => {
+        if (deps.sendInteractiveMessage) {
+          await openTelegramCompactConfirmation(nextMessage.chat.id, {
+            sendInteractiveMessage: deps.sendInteractiveMessage,
+          });
+          return;
+        }
         await handleTelegramCompactCommand({
           isIdle: () => deps.isIdle(commandCtx),
           hasPendingMessages: () => deps.hasPendingMessages(commandCtx),

package/lib/config.ts

@@ -1,7 +1,7 @@
 /**
  * Telegram bridge config and pairing helpers
  * Zones: telegram config, pairing, filesystem
- * Owns persisted bot/session pairing state, local config storage, authorization policy, and first-user pairing side effects
+ * Owns persisted bot/session pairing state, local config storage, live config controls, authorization policy, and first-user pairing side effects
  */
 
 import { existsSync } from "node:fs";
@@ -9,7 +9,7 @@ import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
-import type { TelegramInboundHandlerConfig } from "./inbound-handlers.ts";
+import type { TelegramInboundHandlerConfig } from "./inbound.ts";
 import type { CommandTemplateObjectConfig } from "./command-templates.ts";
 
 const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
@@ -110,6 +110,22 @@ export function updateTelegramVoiceConfig(
   return true;
 }
 
+export function bindGlobalTelegramConfigRuntime(
+  configStore: Pick<TelegramConfigStore, "get" | "set" | "persist">,
+): void {
+  setGlobalTelegramConfigRuntime({
+    updateVoiceConfig(voice) {
+      const current = configStore.get();
+      const next = {
+        ...current,
+        voice: { ...(current.voice ?? {}), ...voice },
+      };
+      configStore.set(next);
+      void configStore.persist(next);
+    },
+  });
+}
+
 export async function readTelegramConfig(
   configPath: string,
 ): Promise<TelegramConfig> {
@@ -266,6 +282,16 @@ export function createTelegramTimeInjectionModeSetter(
 ): (injectionMode: TelegramTimeMode) => Promise<void> {
   return async (injectionMode) => {
     const current = configStore.get();
+    if (injectionMode === "hidden") {
+      const { injectionMode: _injectionMode, ...remainingTime } =
+        current.time ?? {};
+      const next = { ...current };
+      if (Object.keys(remainingTime).length > 0) next.time = remainingTime;
+      else delete next.time;
+      configStore.set(next);
+      await configStore.persist(next);
+      return;
+    }
     const next = {
       ...current,
       time: { ...(current.time ?? {}), injectionMode },
@@ -282,6 +308,21 @@ export function createTelegramProactivePushChatIdGetter(deps: {
   return () => deps.getActiveTurnChatId() ?? deps.getAllowedUserId();
 }
 
+export function createTelegramConfigControls(
+  configStore: Pick<TelegramConfigStore, "get" | "set" | "persist">,
+) {
+  return {
+    isProactivePushEnabled: createTelegramProactivePushChecker(configStore),
+    setProactivePushEnabled: createTelegramProactivePushSetter(configStore),
+    getVoiceReplyMode: createTelegramVoiceReplyModeGetter(configStore),
+    isVoiceReplyModeConfigured:
+      createTelegramVoiceReplyModeConfiguredChecker(configStore),
+    setVoiceReplyMode: createTelegramVoiceReplyModeSetter(configStore),
+    getTimeInjectionMode: createTelegramTimeInjectionModeGetter(configStore),
+    setTimeInjectionMode: createTelegramTimeInjectionModeSetter(configStore),
+  };
+}
+
 export type TelegramAuthorizationState =
   | { kind: "pair"; userId: number }
   | { kind: "allow" }

package/lib/{inbound-handlers.ts → inbound.ts}

@@ -216,9 +216,7 @@ function matchesWildcard(pattern: string, value: string | undefined): boolean {
   return new RegExp(`^${escaped}$`).test(normalizedValue);
 }
 
-function handlerHasSelectors(
-  handler: TelegramInboundHandlerConfig,
-): boolean {
+function handlerHasSelectors(handler: TelegramInboundHandlerConfig): boolean {
   return (
     normalizeStringList(handler.match).length > 0 ||
     normalizeStringList(handler.mime).length > 0 ||
@@ -642,7 +640,10 @@ async function readBuiltInTelegramTextAttachment(
   if (!isTelegramTextMimeType(file.mimeType)) return undefined;
   const content = await readFile(file.path, "utf8");
   const normalized = content.trim();
-  if (!normalized || Buffer.byteLength(normalized, "utf8") > BUILT_IN_TEXT_ATTACHMENT_MAX_BYTES) {
+  if (
+    !normalized ||
+    Buffer.byteLength(normalized, "utf8") > BUILT_IN_TEXT_ATTACHMENT_MAX_BYTES
+  ) {
     return undefined;
   }
   const name = file.fileName || basename(file.path);

package/lib/lifecycle.ts

@@ -1,7 +1,7 @@
 /**
  * Telegram lifecycle hook registration helpers
  * Zones: pi agent lifecycle, telegram session
- * Owns binding prepared Telegram lifecycle runtimes to pi extension lifecycle events
+ * Binds prepared Telegram lifecycle runtimes to pi extension lifecycle events
  */
 
 import type {
@@ -107,16 +107,15 @@ type TelegramLifecycleTimer = number | ReturnType<typeof setTimeout>;
 export interface TelegramCompactionObserverRuntimeDeps<TContext> {
   setCompactionInProgress: (inProgress: boolean) => void;
   updateStatus: (ctx: TContext) => void;
+  startTypingLoop?: (ctx: TContext) => void;
+  stopTypingLoop?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn: (
     dispatch: (ctx: TContext) => void,
   ) => void;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   recordRuntimeEvent?: (category: string, error: unknown) => void;
   timeoutMs?: number;
-  setTimer?: (
-    callback: () => void,
-    ms: number,
-  ) => TelegramLifecycleTimer;
+  setTimer?: (callback: () => void, ms: number) => TelegramLifecycleTimer;
   clearTimer?: (timer: TelegramLifecycleTimer) => void;
 }
 
@@ -149,11 +148,13 @@ export function createTelegramCompactionObserverRuntime<TContext>(
   return {
     onSessionBeforeCompact: (_event, ctx) => {
       deps.setCompactionInProgress(true);
+      deps.startTypingLoop?.(ctx);
       deps.updateStatus(ctx);
       clearFallbackTimer();
       fallbackTimer = setTimer(() => {
         fallbackTimer = undefined;
         deps.setCompactionInProgress(false);
+        deps.stopTypingLoop?.();
         deps.updateStatus(ctx);
         deps.recordRuntimeEvent?.(
           "compact",
@@ -165,10 +166,44 @@ export function createTelegramCompactionObserverRuntime<TContext>(
     onSessionCompact: (_event, ctx) => {
       clearFallbackTimer();
       deps.setCompactionInProgress(false);
+      deps.stopTypingLoop?.();
       deps.updateStatus(ctx);
       requestDispatch();
     },
-    onSessionShutdown: clearFallbackTimer,
+    onSessionShutdown: () => {
+      clearFallbackTimer();
+      deps.stopTypingLoop?.();
+    },
+  };
+}
+
+export interface TelegramMessageActivityTypingDeps<TContext> {
+  hasActiveTurn: () => boolean;
+  startTypingLoop: (ctx: TContext) => void;
+  onMessageStart: TelegramLifecycleRegistrationDeps["onMessageStart"];
+  onMessageUpdate: TelegramLifecycleRegistrationDeps["onMessageUpdate"];
+}
+
+export function createTelegramMessageActivityTypingHooks<
+  TContext extends ExtensionContext,
+>(
+  deps: TelegramMessageActivityTypingDeps<TContext>,
+): Pick<
+  TelegramLifecycleRegistrationDeps,
+  "onMessageStart" | "onMessageUpdate"
+> {
+  const ensureTyping = (ctx: TContext): void => {
+    if (deps.hasActiveTurn()) deps.startTypingLoop(ctx);
+  };
+  return {
+    onMessageStart: async (event, ctx) => {
+      ensureTyping(ctx as TContext);
+      await deps.onMessageStart(event, ctx);
+    },
+    onMessageUpdate: async (event, ctx) => {
+      ensureTyping(ctx as TContext);
+      await deps.onMessageUpdate(event, ctx);
+    },
   };
 }
 

package/lib/menu-model.ts

@@ -983,7 +983,7 @@ export function buildModelMenuReplyMarkup(
         callback_data: "model:scope:scoped",
       },
       {
-        text: state.scope === "all" ? "🟡 All" : "⚫️ All",
+        text: state.scope === "all" ? "🟣 All" : "⚫️ All",
         callback_data: "model:scope:all",
       },
     ]);
@@ -1050,7 +1050,7 @@ export function buildModelDetailMenuReplyMarkup(
           callback_data: "model:scope-enable",
         },
         {
-          text: scoped ? "⚫️ All" : "🟡 All",
+          text: scoped ? "⚫️ All" : "🟣 All",
           callback_data: "model:scope-disable",
         },
       ],
@@ -1091,7 +1091,7 @@ export function buildModelPageMenuReplyMarkup(
           return {
             text:
               pageIndex === menuPage.page
-                ? `🟢 ${pageIndex + 1}`
+                ? `🟣 ${pageIndex + 1}`
                 : String(pageIndex + 1),
             callback_data: `model:page:${pageIndex}`,
           };

package/lib/menu-queue.ts

@@ -162,7 +162,7 @@ function buildTelegramQueueItemSubmenuReplyMarkup(
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
         },
         {
-          text: isPriority ? "⚫️ Normal" : "🟡 Normal",
+          text: isPriority ? "⚫️ Normal" : "🟣 Normal",
           callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
         },
       ],