@llblab/pi-telegram 0.52.2 → 0.53.1

package/dist/lib/menu-status.js

@@ -4,26 +4,13 @@
  * Owns status-menu payloads, status callback handling, and status-menu message rendering
  */
 import { formatTelegramCommandEmojiPrefix } from "./commands.js";
-import { getTelegramSectionMainMenuRows, } from "./sections.js";
-import { formatStatusButtonLabel, } from "./menu-model.js";
+import { refuseUnavailableTelegramThinkingControls } from "./menu-thinking.js";
+import { editTelegramMenuMessage, formatStatusButtonLabel, sendTelegramMenuMessage, } from "./menu-model.js";
 import { getCanonicalModelId, } from "./model.js";
+import { getTelegramSectionMainMenuRows, } from "./sections.js";
 function isTelegramStatusMenuCallbackAction(data, action) {
     return data === `menu:${action}` || data === `status:${action}`;
 }
-function applyTelegramMenuRenderPayload(state, payload) {
-    state.mode = payload.nextMode;
-    return payload;
-}
-async function editTelegramMenuMessage(state, payload, deps) {
-    const appliedPayload = applyTelegramMenuRenderPayload(state, payload);
-    await deps.editInteractiveMessage(state.chatId, state.messageId, appliedPayload.text, appliedPayload.mode, appliedPayload.replyMarkup);
-}
-function sendTelegramMenuMessage(state, payload, deps) {
-    const appliedPayload = applyTelegramMenuRenderPayload(state, payload);
-    return deps.sendInteractiveMessage(state.chatId, appliedPayload.text, appliedPayload.mode, appliedPayload.replyMarkup, state.threadId !== undefined
-        ? { target: { chatId: state.chatId, threadId: state.threadId } }
-        : undefined);
-}
 export async function openTelegramStatusMenu(deps) {
     const state = await deps.getModelMenuState();
     const messageId = await deps.sendStatusMenu(state, deps.buildStatusHtml(), deps.getActiveModel(), deps.getThinkingLevel(), deps.getQueueItemCount?.() ?? 0);
@@ -48,14 +35,8 @@ export async function handleTelegramStatusMenuCallbackAction(callbackQueryId, da
     }
     if (!isTelegramStatusMenuCallbackAction(data, "thinking"))
         return false;
-    if (deps.isVoiceReplyActive?.()) {
-        await deps.answerCallbackQuery(callbackQueryId, "Thinking controls are disabled during voice replies.");
-        return true;
-    }
-    if (!activeModel?.reasoning) {
-        await deps.answerCallbackQuery(callbackQueryId, "This model has no reasoning controls.");
+    if (await refuseUnavailableTelegramThinkingControls(callbackQueryId, activeModel, deps))
         return true;
-    }
     await deps.updateThinkingMenuMessage();
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
@@ -83,10 +64,12 @@ export function buildStatusReplyMarkup(activeModel, currentThinkingLevel, queueI
         },
     ]);
     if (pendingCancellationCount > 0)
-        rows.push([{
+        rows.push([
+            {
                 text: `❌ Pending cancellations: ${pendingCancellationCount}`,
                 callback_data: "reroutecancel:review:open",
-            }]);
+            },
+        ]);
     if (sectionRegistry) {
         const sectionRows = getTelegramSectionMainMenuRows(sectionRegistry);
         for (const row of sectionRows) {

package/dist/lib/menu-thinking.d.ts

@@ -3,7 +3,7 @@
  * Zones: telegram ui, thinking controls, menu composition
  * Owns thinking-menu text, reply markup, callback handling, and thinking-menu message rendering
  */
-import type { TelegramMenuMessageRuntimeDeps, TelegramMenuRenderPayload, TelegramModelMenuState, TelegramReplyMarkup } from "./menu-model.ts";
+import { type TelegramMenuMessageRuntimeDeps, type TelegramMenuRenderPayload, type TelegramModelMenuState, type TelegramReplyMarkup } from "./menu-model.ts";
 import { type MenuModel, type ThinkingLevel } from "./model.ts";
 export interface TelegramThinkingMenuCallbackDeps {
     setThinkingLevel: (level: ThinkingLevel) => void;
@@ -19,6 +19,11 @@ export interface TelegramThinkingMenuOpenDeps<TModel extends MenuModel = MenuMod
     storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
     isVoiceReplyActive?: () => boolean;
 }
+/** Answers and returns true when voice replies or a non-reasoning model disable thinking controls. */
+export declare function refuseUnavailableTelegramThinkingControls(callbackQueryId: string, activeModel: MenuModel | undefined, deps: {
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+    isVoiceReplyActive?: () => boolean;
+}): Promise<boolean>;
 export declare function handleTelegramThinkingMenuCallbackAction(callbackQueryId: string, data: string | undefined, activeModel: MenuModel | undefined, deps: TelegramThinkingMenuCallbackDeps): Promise<boolean>;
 export declare function buildThinkingMenuText(): string;
 export declare function buildThinkingMenuReplyMarkup(currentThinkingLevel: ThinkingLevel): TelegramReplyMarkup;

package/dist/lib/menu-thinking.js

@@ -3,42 +3,35 @@
  * Zones: telegram ui, thinking controls, menu composition
  * Owns thinking-menu text, reply markup, callback handling, and thinking-menu message rendering
  */
+import { editTelegramMenuMessage, sendTelegramMenuMessage, } from "./menu-model.js";
 import { isThinkingLevel, THINKING_LEVELS, } from "./model.js";
 function parseTelegramThinkingMenuCallbackAction(data) {
     if (!data?.startsWith("thinking:set:"))
         return undefined;
     return { kind: "thinking:set", level: data.slice("thinking:set:".length) };
 }
-function applyTelegramMenuRenderPayload(state, payload) {
-    state.mode = payload.nextMode;
-    return payload;
-}
-async function editTelegramMenuMessage(state, payload, deps) {
-    const appliedPayload = applyTelegramMenuRenderPayload(state, payload);
-    await deps.editInteractiveMessage(state.chatId, state.messageId, appliedPayload.text, appliedPayload.mode, appliedPayload.replyMarkup);
-}
-function sendTelegramMenuMessage(state, payload, deps) {
-    const appliedPayload = applyTelegramMenuRenderPayload(state, payload);
-    return deps.sendInteractiveMessage(state.chatId, appliedPayload.text, appliedPayload.mode, appliedPayload.replyMarkup, state.threadId !== undefined
-        ? { target: { chatId: state.chatId, threadId: state.threadId } }
-        : undefined);
+/** Answers and returns true when voice replies or a non-reasoning model disable thinking controls. */
+export async function refuseUnavailableTelegramThinkingControls(callbackQueryId, activeModel, deps) {
+    if (deps.isVoiceReplyActive?.()) {
+        await deps.answerCallbackQuery(callbackQueryId, "Thinking controls are disabled during voice replies");
+        return true;
+    }
+    if (!activeModel?.reasoning) {
+        await deps.answerCallbackQuery(callbackQueryId, "This model has no reasoning controls");
+        return true;
+    }
+    return false;
 }
 export async function handleTelegramThinkingMenuCallbackAction(callbackQueryId, data, activeModel, deps) {
     const action = parseTelegramThinkingMenuCallbackAction(data);
     if (!action)
         return false;
     if (!isThinkingLevel(action.level)) {
-        await deps.answerCallbackQuery(callbackQueryId, "Invalid thinking level.");
-        return true;
-    }
-    if (deps.isVoiceReplyActive?.()) {
-        await deps.answerCallbackQuery(callbackQueryId, "Thinking controls are disabled during voice replies.");
+        await deps.answerCallbackQuery(callbackQueryId, "Invalid thinking level");
         return true;
     }
-    if (!activeModel?.reasoning) {
-        await deps.answerCallbackQuery(callbackQueryId, "This model has no reasoning controls.");
+    if (await refuseUnavailableTelegramThinkingControls(callbackQueryId, activeModel, deps))
         return true;
-    }
     deps.setThinkingLevel(action.level);
     await deps.updateThinkingMenuMessage();
     await deps.answerCallbackQuery(callbackQueryId, `Thinking: ${deps.getCurrentThinkingLevel()}`);

package/dist/lib/menu.d.ts

@@ -3,10 +3,10 @@
  * Zones: telegram ui, controls, status menu
  * Owns app-menu/status state, inline UI text, and callback composition while model/thinking/queue menu details live in dedicated domains
  */
-import { type TelegramMenuMessageRuntimeDeps, type TelegramModelMenuState, type TelegramModelMenuStateBuilderContext, type TelegramModelMenuStateBuilderDeps, type TelegramReplyMarkup } from "./menu-model.ts";
+import { type TelegramMenuMessageRuntimeDeps, type TelegramModelMenuState, type TelegramReplyMarkup } from "./menu-model.ts";
 import { type MenuModel, type ScopedTelegramModel, type TelegramModelSwitchContinuationSource, type ThinkingLevel } from "./model.ts";
-import type { TelegramInputRichMessage } from "./telegram-api.ts";
 import { type TelegramSectionRegistry } from "./sections.ts";
+import type { TelegramApiCallOptions, TelegramInputRichMessage } from "./telegram-api.ts";
 export { applyTelegramModelPageSelection, applyTelegramModelScopeSelection, buildModelMenuReplyMarkup, buildModelPageMenuReplyMarkup, buildTelegramModelCallbackPlan, buildTelegramModelMenuRenderPayload, buildTelegramModelMenuState, buildTelegramModelMenuStateRuntime, buildTelegramModelPageMenuRenderPayload, createTelegramModelMenuRuntime, createTelegramModelMenuStateBuilder, formatScopedModelButtonText, getModelMenuItems, getStoredTelegramModelMenuState, getTelegramModelMenuPage, getTelegramModelSelection, handleTelegramModelMenuCallbackAction, MODEL_MENU_TITLE, MODEL_PAGE_MENU_TITLE, openTelegramModelMenu, pruneStoredTelegramModelMenus, resolveCachedTelegramModelMenuInputs, sendTelegramModelMenuMessage, storeTelegramModelMenuState, TELEGRAM_MODEL_PAGE_SIZE, updateTelegramModelMenuMessage, } from "./menu-model.ts";
 export type { BuildTelegramModelCallbackPlanParams, BuildTelegramModelMenuStateParams, CachedTelegramModelMenuInputs, MenuSettingsManager, StoredTelegramModelMenuState, TelegramMenuMessageRuntimeDeps, TelegramMenuMutationResult, TelegramMenuRenderPayload, TelegramMenuSelectionResult, TelegramModelCallbackPlan, TelegramModelMenuCallbackDeps, TelegramModelMenuInputCacheDeps, TelegramModelMenuOpenDeps, TelegramModelMenuPage, TelegramModelMenuRuntime, TelegramModelMenuRuntimeContext, TelegramModelMenuRuntimeOptions, TelegramModelMenuState, TelegramModelMenuStateBuilderContext, TelegramModelMenuStateBuilderDeps, TelegramModelMenuStoreOptions, TelegramModelScope, TelegramReplyMarkup, } from "./menu-model.ts";
 export { buildStatusReplyMarkup, buildTelegramStatusMenuRenderPayload, handleTelegramStatusMenuCallbackAction, openTelegramStatusMenu, sendTelegramStatusMessage, updateTelegramStatusMessage, } from "./menu-status.ts";
@@ -93,6 +93,7 @@ export interface TelegramMenuActionRuntimeDeps<TContext, TModel extends MenuMode
             threadId?: number;
         };
         parseMode?: "HTML";
+        assertAuthority?: TelegramApiCallOptions["assertAuthority"];
     }) => Promise<unknown>;
     sectionRegistry?: TelegramSectionRegistry;
     isVoiceReplyActive?: () => boolean;
@@ -101,70 +102,16 @@ export interface TelegramMenuActionRuntime<TContext, TModel extends MenuModel =
     updateModelMenuMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
     updateThinkingMenuMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
     updateStatusMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
-    sendStatusMessage: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number) => Promise<void>;
-    openModelMenu: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number) => Promise<void>;
-    openThinkingMenu: (chatId: number, replyToMessageId: number, ctx: TContext) => Promise<void>;
+    sendStatusMessage: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
+    openModelMenu: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
+    openThinkingMenu: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
 }
-export type TelegramMenuCallbackAction = {
-    kind: "ignore";
-} | {
-    kind: "status";
-    action: "model" | "thinking" | "queue" | "settings";
-} | {
-    kind: "thinking:set";
-    level: string;
-} | {
-    kind: "model";
-    action: "noop" | "scope" | "page" | "pages" | "open" | "pick" | "pick-selected" | "scope-enable" | "scope-disable" | "scope-toggle";
-    value?: string;
-};
-export declare function parseTelegramMenuCallbackAction(data: string | undefined): TelegramMenuCallbackAction;
 export declare function handleTelegramMenuCallbackEntry(callbackQueryId: string, data: string | undefined, state: TelegramModelMenuState | undefined, deps: TelegramMenuCallbackEntryDeps): Promise<void>;
 export declare function handleStoredTelegramMenuCallback<TModel extends MenuModel = MenuModel>(query: MenuCallbackQuery, deps: StoredTelegramMenuCallbackDeps<TModel>): Promise<void>;
-export interface TelegramMenuCallbackRuntimeAdapterDeps<TContext, TModel extends MenuModel = MenuModel> {
-    getStoredModelMenuState: (messageId: number | undefined, chatId?: number) => TelegramModelMenuState<TModel> | undefined;
-    getActiveModel: (ctx: TContext) => TModel | undefined;
-    getThinkingLevel: () => ThinkingLevel;
-    setThinkingLevel: (level: ThinkingLevel) => void;
-    updateStatus: (ctx: TContext, error?: string) => void;
-    updateModelMenuMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
-    updateThinkingMenuMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
-    updateStatusMessage: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
-    updateSettingsMenuMessage?: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
-    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
-    isIdle: (ctx: TContext) => boolean;
-    hasAbortHandler: () => boolean;
+export type TelegramMenuCallbackRuntimeAdapterDeps<TContext, TModel extends MenuModel = MenuModel> = Omit<TelegramMenuCallbackRuntimeDeps<TContext, TModel>, "hasActiveToolExecutions"> & {
     getActiveToolExecutions: () => number;
-    persistScopedModelPatterns?: (patterns: string[], ctx: TContext) => Promise<void>;
-    setModel: (model: TModel) => Promise<boolean>;
-    setCurrentModel: (model: TModel, ctx: TContext) => void;
-    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => void;
-    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => Promise<boolean> | boolean;
-    sectionRegistry?: TelegramSectionRegistry;
-    editInteractiveMessage?: (chatId: number, messageId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup) => Promise<void>;
-    sendInteractiveMessage?: (chatId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup, options?: {
-        target?: {
-            chatId: number;
-            threadId?: number;
-        };
-    }) => Promise<number | undefined>;
-    sendSectionRichMessage?: (chatId: number, message: TelegramInputRichMessage, options?: {
-        target?: {
-            chatId: number;
-            threadId?: number;
-        };
-    }) => Promise<number | undefined>;
-    enqueueSectionPrompt?: (prompt: string, ctx: TContext, target?: {
-        chatId: number;
-        threadId?: number;
-    }, source?: unknown) => Promise<void>;
-    deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
-}
+};
 export declare function createTelegramMenuCallbackHandler<TQuery extends MenuCallbackQuery, TContext, TModel extends MenuModel = MenuModel>(deps: TelegramMenuCallbackRuntimeDeps<TContext, TModel>): (query: TQuery, ctx: TContext) => Promise<void>;
 export declare function createTelegramMenuCallbackHandlerForContext<TQuery extends MenuCallbackQuery, TContext, TModel extends MenuModel = MenuModel>(deps: TelegramMenuCallbackRuntimeAdapterDeps<TContext, TModel>): (query: TQuery, ctx: TContext) => Promise<void>;
 export declare function handleTelegramMenuCallbackRuntime<TQuery extends MenuCallbackQuery, TContext, TModel extends MenuModel = MenuModel>(query: TQuery, ctx: TContext, deps: TelegramMenuCallbackRuntimeDeps<TContext, TModel>): Promise<void>;
-export interface TelegramMenuActionRuntimeWithStateBuilderDeps<TModel extends MenuModel = MenuModel, TContext extends TelegramModelMenuStateBuilderContext<TModel> = TelegramModelMenuStateBuilderContext<TModel>> extends Omit<TelegramMenuActionRuntimeDeps<TContext, TModel>, "getModelMenuState">, TelegramModelMenuStateBuilderDeps<TModel, TContext> {
-    isVoiceReplyActive?: () => boolean;
-}
-export declare function createTelegramMenuActionRuntimeWithStateBuilder<TModel extends MenuModel = MenuModel, TContext extends TelegramModelMenuStateBuilderContext<TModel> = TelegramModelMenuStateBuilderContext<TModel>>(deps: TelegramMenuActionRuntimeWithStateBuilderDeps<TModel, TContext>): TelegramMenuActionRuntime<TContext, TModel>;
 export declare function createTelegramMenuActionRuntime<TContext, TModel extends MenuModel = MenuModel>(deps: TelegramMenuActionRuntimeDeps<TContext, TModel>): TelegramMenuActionRuntime<TContext, TModel>;

package/dist/lib/menu.js

@@ -3,56 +3,20 @@
  * Zones: telegram ui, controls, status menu
  * Owns app-menu/status state, inline UI text, and callback composition while model/thinking/queue menu details live in dedicated domains
  */
-import { createTelegramModelMenuStateBuilder, handleTelegramModelMenuCallbackAction, openTelegramModelMenu, sendTelegramModelMenuMessage, updateTelegramModelMenuMessage, } from "./menu-model.js";
+import { createTelegramMenuDelivery, handleTelegramModelMenuCallbackAction, openTelegramModelMenu, sendTelegramModelMenuMessage, updateTelegramModelMenuMessage, } from "./menu-model.js";
 import { handleTelegramStatusMenuCallbackAction, openTelegramStatusMenu, sendTelegramStatusMessage, updateTelegramStatusMessage, } from "./menu-status.js";
 import { handleTelegramThinkingMenuCallbackAction, openTelegramThinkingMenu, updateTelegramThinkingMenuMessage, } from "./menu-thinking.js";
 import { handleTelegramSectionCallback, handleTelegramSectionOpen, handleTelegramSectionSettingsOpen, parseTelegramSectionCallback, } from "./sections.js";
 export { applyTelegramModelPageSelection, applyTelegramModelScopeSelection, buildModelMenuReplyMarkup, buildModelPageMenuReplyMarkup, buildTelegramModelCallbackPlan, buildTelegramModelMenuRenderPayload, buildTelegramModelMenuState, buildTelegramModelMenuStateRuntime, buildTelegramModelPageMenuRenderPayload, createTelegramModelMenuRuntime, createTelegramModelMenuStateBuilder, formatScopedModelButtonText, getModelMenuItems, getStoredTelegramModelMenuState, getTelegramModelMenuPage, getTelegramModelSelection, handleTelegramModelMenuCallbackAction, MODEL_MENU_TITLE, MODEL_PAGE_MENU_TITLE, openTelegramModelMenu, pruneStoredTelegramModelMenus, resolveCachedTelegramModelMenuInputs, sendTelegramModelMenuMessage, storeTelegramModelMenuState, TELEGRAM_MODEL_PAGE_SIZE, updateTelegramModelMenuMessage, } from "./menu-model.js";
 export { buildStatusReplyMarkup, buildTelegramStatusMenuRenderPayload, handleTelegramStatusMenuCallbackAction, openTelegramStatusMenu, sendTelegramStatusMessage, updateTelegramStatusMessage, } from "./menu-status.js";
 export { buildTelegramThinkingMenuRenderPayload, buildThinkingMenuReplyMarkup, buildThinkingMenuText, handleTelegramThinkingMenuCallbackAction, openTelegramThinkingMenu, updateTelegramThinkingMenuMessage, } from "./menu-thinking.js";
-export function parseTelegramMenuCallbackAction(data) {
-    if (data === "menu:model" || data === "status:model") {
-        return { kind: "status", action: "model" };
-    }
-    if (data === "menu:thinking" || data === "status:thinking") {
-        return { kind: "status", action: "thinking" };
-    }
-    if (data === "menu:queue" || data === "status:queue") {
-        return { kind: "status", action: "queue" };
-    }
-    if (data === "menu:settings" || data === "status:settings") {
-        return { kind: "status", action: "settings" };
-    }
-    if (data?.startsWith("thinking:set:")) {
-        return {
-            kind: "thinking:set",
-            level: data.slice("thinking:set:".length),
-        };
-    }
-    if (data?.startsWith("model:")) {
-        const [, action, value] = data.split(":");
-        if (action === "noop" ||
-            action === "scope" ||
-            action === "page" ||
-            action === "pages" ||
-            action === "open" ||
-            action === "pick" ||
-            action === "pick-selected" ||
-            action === "scope-enable" ||
-            action === "scope-disable" ||
-            action === "scope-toggle") {
-            return { kind: "model", action, value };
-        }
-    }
-    return { kind: "ignore" };
-}
 export async function handleTelegramMenuCallbackEntry(callbackQueryId, data, state, deps) {
     if (!data) {
         await deps.answerCallbackQuery(callbackQueryId);
         return;
     }
     if (!state) {
-        await deps.answerCallbackQuery(callbackQueryId, "Interactive message expired.");
+        await deps.answerCallbackQuery(callbackQueryId, "Interactive message expired");
         return;
     }
     const handled = (await deps.handleStatusAction()) ||
@@ -87,38 +51,17 @@ export function createTelegramMenuCallbackHandler(deps) {
     return (query, ctx) => handleTelegramMenuCallbackRuntime(query, ctx, deps);
 }
 export function createTelegramMenuCallbackHandlerForContext(deps) {
+    const { getActiveToolExecutions, ...ports } = deps;
     return createTelegramMenuCallbackHandler({
-        getStoredModelMenuState: deps.getStoredModelMenuState,
-        getActiveModel: deps.getActiveModel,
-        getThinkingLevel: deps.getThinkingLevel,
-        setThinkingLevel: deps.setThinkingLevel,
-        updateStatus: deps.updateStatus,
-        updateModelMenuMessage: deps.updateModelMenuMessage,
-        updateThinkingMenuMessage: deps.updateThinkingMenuMessage,
-        updateStatusMessage: deps.updateStatusMessage,
-        updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
-        answerCallbackQuery: deps.answerCallbackQuery,
-        isIdle: deps.isIdle,
-        hasAbortHandler: deps.hasAbortHandler,
-        hasActiveToolExecutions: () => deps.getActiveToolExecutions() > 0,
-        persistScopedModelPatterns: deps.persistScopedModelPatterns,
-        setModel: deps.setModel,
-        setCurrentModel: deps.setCurrentModel,
-        stagePendingModelSwitch: deps.stagePendingModelSwitch,
-        restartInterruptedTelegramTurn: deps.restartInterruptedTelegramTurn,
-        sectionRegistry: deps.sectionRegistry,
-        editInteractiveMessage: deps.editInteractiveMessage,
-        sendInteractiveMessage: deps.sendInteractiveMessage,
-        sendSectionRichMessage: deps.sendSectionRichMessage,
-        enqueueSectionPrompt: deps.enqueueSectionPrompt,
-        deleteMessage: deps.deleteMessage,
+        ...ports,
+        hasActiveToolExecutions: () => getActiveToolExecutions() > 0,
     });
 }
 export async function handleTelegramMenuCallbackRuntime(query, ctx, deps) {
     if (query.data === "menu:back") {
         const state = deps.getStoredModelMenuState(query.message?.message_id, query.message?.chat?.id);
         if (!state) {
-            await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+            await deps.answerCallbackQuery(query.id, "Interactive message expired");
             return;
         }
         await deps.updateStatusMessage(state, ctx);
@@ -139,61 +82,37 @@ export async function handleTelegramMenuCallbackRuntime(query, ctx, deps) {
                 : undefined;
             if (typeof chatId === "number" && typeof messageId === "number") {
                 const { token, action, payload } = parsed;
+                const sectionDeps = {
+                    answerCallbackQuery: deps.answerCallbackQuery,
+                    target,
+                    editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
+                    sendInteractiveMessage: deps.sendInteractiveMessage ?? (async () => undefined),
+                    sendRichMessage: deps.sendSectionRichMessage ??
+                        (async () => {
+                            throw new Error("Rich Message delivery is unavailable");
+                        }),
+                    enqueuePrompt: deps.enqueueSectionPrompt
+                        ? (prompt) => deps.enqueueSectionPrompt(prompt, ctx, target, query)
+                        : async () => { },
+                    deleteMessage: deps.deleteMessage ?? (async () => { }),
+                };
                 if (action === "open") {
                     const state = deps.getStoredModelMenuState(messageId, chatId);
                     if (!state) {
-                        await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+                        await deps.answerCallbackQuery(query.id, "Interactive message expired");
                         return;
                     }
-                    const handled = await handleTelegramSectionOpen(deps.sectionRegistry, token, chatId, messageId, query.id, {
-                        answerCallbackQuery: deps.answerCallbackQuery,
-                        target,
-                        editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
-                        sendInteractiveMessage: deps.sendInteractiveMessage ?? (async () => undefined),
-                        sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
-                            throw new Error("Rich Message delivery is unavailable");
-                        }),
-                        enqueuePrompt: deps.enqueueSectionPrompt
-                            ? (prompt) => deps.enqueueSectionPrompt(prompt, ctx, target, query)
-                            : async () => { },
-                        deleteMessage: deps.deleteMessage ?? (async () => { }),
-                    });
+                    const handled = await handleTelegramSectionOpen(deps.sectionRegistry, token, chatId, messageId, query.id, sectionDeps);
                     if (handled)
                         return;
                 }
                 else if (action === "settings") {
-                    if (typeof chatId === "number" && typeof messageId === "number") {
-                        const handled = await handleTelegramSectionSettingsOpen(deps.sectionRegistry, token, chatId, messageId, query.id, {
-                            answerCallbackQuery: deps.answerCallbackQuery,
-                            target,
-                            editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
-                            sendInteractiveMessage: deps.sendInteractiveMessage ?? (async () => undefined),
-                            sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
-                                throw new Error("Rich Message delivery is unavailable");
-                            }),
-                            enqueuePrompt: deps.enqueueSectionPrompt
-                                ? (prompt) => deps.enqueueSectionPrompt(prompt, ctx, target, query)
-                                : async () => { },
-                            deleteMessage: deps.deleteMessage ?? (async () => { }),
-                        });
-                        if (handled)
-                            return;
-                    }
+                    const handled = await handleTelegramSectionSettingsOpen(deps.sectionRegistry, token, chatId, messageId, query.id, sectionDeps);
+                    if (handled)
+                        return;
                 }
                 else {
-                    const handled = await handleTelegramSectionCallback(deps.sectionRegistry, token, action, payload, chatId, messageId, query.id, {
-                        answerCallbackQuery: deps.answerCallbackQuery,
-                        target,
-                        editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
-                        sendInteractiveMessage: deps.sendInteractiveMessage ?? (async () => undefined),
-                        sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
-                            throw new Error("Rich Message delivery is unavailable");
-                        }),
-                        enqueuePrompt: deps.enqueueSectionPrompt
-                            ? (prompt) => deps.enqueueSectionPrompt(prompt, ctx, target, query)
-                            : async () => { },
-                        deleteMessage: deps.deleteMessage ?? (async () => { }),
-                    });
+                    const handled = await handleTelegramSectionCallback(deps.sectionRegistry, token, action, payload, chatId, messageId, query.id, sectionDeps);
                     if (handled)
                         return;
                 }
@@ -257,67 +176,76 @@ export async function handleTelegramMenuCallbackRuntime(query, ctx, deps) {
         answerCallbackQuery: deps.answerCallbackQuery,
     });
 }
-export function createTelegramMenuActionRuntimeWithStateBuilder(deps) {
-    return createTelegramMenuActionRuntime({
-        getModelMenuState: createTelegramModelMenuStateBuilder({
-            runtime: deps.runtime,
-            createSettingsManager: deps.createSettingsManager,
-            getActiveModel: deps.getActiveModel,
-        }),
-        getActiveModel: deps.getActiveModel,
-        getThinkingLevel: deps.getThinkingLevel,
-        getQueueItemCount: deps.getQueueItemCount,
-        getPendingCancellationCount: deps.getPendingCancellationCount,
-        buildStatusHtml: deps.buildStatusHtml,
-        storeModelMenuState: deps.storeModelMenuState,
-        isIdle: deps.isIdle,
-        canOfferInFlightModelSwitch: deps.canOfferInFlightModelSwitch,
-        sendTextReply: deps.sendTextReply,
-        editInteractiveMessage: deps.editInteractiveMessage,
-        sendInteractiveMessage: deps.sendInteractiveMessage,
-        sectionRegistry: deps.sectionRegistry,
-    });
-}
 export function createTelegramMenuActionRuntime(deps) {
     return {
         updateModelMenuMessage: (state, ctx) => updateTelegramModelMenuMessage(state, deps.getActiveModel(ctx), deps),
         updateThinkingMenuMessage: (state, ctx) => updateTelegramThinkingMenuMessage(state, deps.getActiveModel(ctx), deps.getThinkingLevel(), deps),
         updateStatusMessage: (state, ctx) => updateTelegramStatusMessage(state, deps.buildStatusHtml(ctx), deps.getActiveModel(ctx), deps.getThinkingLevel(), deps, deps.getQueueItemCount?.() ?? 0, deps.sectionRegistry, deps.isVoiceReplyActive?.(), deps.getPendingCancellationCount?.() ?? 0),
-        sendStatusMessage: (chatId, replyToMessageId, ctx, threadId) => openTelegramStatusMenu({
-            isIdle: () => deps.isIdle(ctx),
-            sendBusyMessage: async () => {
-                await deps.sendTextReply(chatId, replyToMessageId, "<b>⏳ Cannot open status while Pi is busy. Send /abort, /next, or /stop.</b>", { target: { chatId, threadId }, parseMode: "HTML" });
-            },
-            getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
-            buildStatusHtml: () => deps.buildStatusHtml(ctx),
-            getActiveModel: () => deps.getActiveModel(ctx),
-            getThinkingLevel: deps.getThinkingLevel,
-            getQueueItemCount: deps.getQueueItemCount,
-            sendStatusMenu: (state, statusHtml, activeModel, thinkingLevel, queueItemCount) => sendTelegramStatusMessage(state, statusHtml, activeModel, thinkingLevel, deps, queueItemCount, deps.sectionRegistry, deps.isVoiceReplyActive?.(), deps.getPendingCancellationCount?.() ?? 0),
-            storeModelMenuState: deps.storeModelMenuState,
-        }),
-        openModelMenu: (chatId, replyToMessageId, ctx, threadId) => openTelegramModelMenu({
-            isIdle: () => deps.isIdle(ctx),
-            canOfferInFlightModelSwitch: () => deps.canOfferInFlightModelSwitch(ctx),
-            sendBusyMessage: async () => {
-                await deps.sendTextReply(chatId, replyToMessageId, "<b>⏳ Cannot switch model while Pi is busy. Send /abort, /next, or /stop.</b>", { target: { chatId, threadId }, parseMode: "HTML" });
-            },
-            sendNoModelsMessage: async () => {
-                await deps.sendTextReply(chatId, replyToMessageId, "<b>🚫 No available models with configured auth.</b>", { target: { chatId, threadId }, parseMode: "HTML" });
-            },
-            getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
-            getActiveModel: () => deps.getActiveModel(ctx),
-            sendModelMenu: (state, activeModel) => sendTelegramModelMenuMessage(state, activeModel, deps),
-            storeModelMenuState: deps.storeModelMenuState,
-        }),
-        openThinkingMenu: (chatId, _replyToMessageId, ctx) => openTelegramThinkingMenu({
-            getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
-            getActiveModel: () => deps.getActiveModel(ctx),
-            getThinkingLevel: deps.getThinkingLevel,
-            storeModelMenuState: deps.storeModelMenuState,
-            editInteractiveMessage: deps.editInteractiveMessage,
-            sendInteractiveMessage: deps.sendInteractiveMessage,
-            isVoiceReplyActive: deps.isVoiceReplyActive,
-        }),
+        sendStatusMessage: (chatId, replyToMessageId, ctx, threadId, options) => {
+            const delivery = createTelegramMenuDelivery({ chatId, threadId }, options, deps);
+            return openTelegramStatusMenu({
+                isIdle: () => deps.isIdle(ctx),
+                sendBusyMessage: async () => {
+                    await deps.sendTextReply(chatId, replyToMessageId, "<b>⏳ Cannot open status while Pi is busy. Send /abort, /next, or /stop.</b>", {
+                        target: { chatId, threadId },
+                        parseMode: "HTML",
+                        ...(delivery.assertAuthority
+                            ? { assertAuthority: delivery.assertAuthority }
+                            : {}),
+                    });
+                },
+                getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
+                buildStatusHtml: () => deps.buildStatusHtml(ctx),
+                getActiveModel: () => deps.getActiveModel(ctx),
+                getThinkingLevel: deps.getThinkingLevel,
+                getQueueItemCount: deps.getQueueItemCount,
+                sendStatusMenu: (state, statusHtml, activeModel, thinkingLevel, queueItemCount) => sendTelegramStatusMessage(state, statusHtml, activeModel, thinkingLevel, {
+                    ...deps,
+                    sendInteractiveMessage: delivery.sendInteractiveMessage,
+                }, queueItemCount, deps.sectionRegistry, deps.isVoiceReplyActive?.(), deps.getPendingCancellationCount?.() ?? 0),
+                storeModelMenuState: delivery.storeModelMenuState,
+            });
+        },
+        openModelMenu: (chatId, replyToMessageId, ctx, threadId, options) => {
+            const delivery = createTelegramMenuDelivery({ chatId, threadId }, options, deps);
+            const assertAuthority = delivery.assertAuthority;
+            return openTelegramModelMenu({
+                isIdle: () => deps.isIdle(ctx),
+                canOfferInFlightModelSwitch: () => deps.canOfferInFlightModelSwitch(ctx),
+                sendBusyMessage: async () => {
+                    await deps.sendTextReply(chatId, replyToMessageId, "<b>⏳ Cannot switch model while Pi is busy. Send /abort, /next, or /stop.</b>", {
+                        target: { chatId, threadId },
+                        parseMode: "HTML",
+                        ...(assertAuthority ? { assertAuthority } : {}),
+                    });
+                },
+                sendNoModelsMessage: async () => {
+                    await deps.sendTextReply(chatId, replyToMessageId, "<b>🚫 No available models with configured auth.</b>", {
+                        target: { chatId, threadId },
+                        parseMode: "HTML",
+                        ...(assertAuthority ? { assertAuthority } : {}),
+                    });
+                },
+                getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
+                getActiveModel: () => deps.getActiveModel(ctx),
+                sendModelMenu: (state, activeModel) => sendTelegramModelMenuMessage(state, activeModel, {
+                    ...deps,
+                    sendInteractiveMessage: delivery.sendInteractiveMessage,
+                }),
+                storeModelMenuState: delivery.storeModelMenuState,
+            });
+        },
+        openThinkingMenu: (chatId, _replyToMessageId, ctx, threadId, options) => {
+            const delivery = createTelegramMenuDelivery({ chatId, threadId }, options, deps);
+            return openTelegramThinkingMenu({
+                getModelMenuState: () => deps.getModelMenuState(chatId, ctx, threadId),
+                getActiveModel: () => deps.getActiveModel(ctx),
+                getThinkingLevel: deps.getThinkingLevel,
+                storeModelMenuState: delivery.storeModelMenuState,
+                editInteractiveMessage: deps.editInteractiveMessage,
+                sendInteractiveMessage: delivery.sendInteractiveMessage,
+                isVoiceReplyActive: deps.isVoiceReplyActive,
+            });
+        },
     };
 }

package/dist/lib/model.d.ts

@@ -3,7 +3,7 @@
  * Zones: pi agent model control, telegram controls, queue continuation
  * Owns model identity, thinking levels, scoped resolution, current-model state, and in-flight model switching
  */
-import type { PendingTelegramTurn } from "./queue.ts";
+import { type PendingTelegramTurn } from "./queue.ts";
 export interface MenuModel {
     provider: string;
     id: string;

package/dist/lib/model.js

@@ -3,6 +3,7 @@
  * Zones: pi agent model control, telegram controls, queue continuation
  * Owns model identity, thinking levels, scoped resolution, current-model state, and in-flight model switching
  */
+import { truncateTelegramQueueSummary, } from "./queue.js";
 import { TELEGRAM_PREFIX } from "./turns.js";
 export const THINKING_LEVELS = [
     "off",
@@ -277,21 +278,6 @@ export function restartTelegramModelSwitchContinuation(state) {
     state.abort();
     return true;
 }
-function truncateTelegramModelSwitchStatusSummary(text, maxWords = 4, maxLength = 32) {
-    const normalized = text.replace(/\s+/g, " ").trim();
-    if (!normalized)
-        return "";
-    const words = normalized.split(" ");
-    let summary = words.slice(0, maxWords).join(" ");
-    if (summary.length === 0)
-        summary = normalized;
-    if (summary.length > maxLength) {
-        summary = summary.slice(0, maxLength).trimEnd();
-    }
-    return summary.length < normalized.length || words.length > maxWords
-        ? `${summary}…`
-        : summary;
-}
 export function buildTelegramModelSwitchContinuationText(telegramPrefix, model, thinkingLevel) {
     const modelLabel = `${model.provider}/${model.id}`;
     const thinkingSuffix = thinkingLevel ? `; thinking: ${thinkingLevel}` : "";
@@ -299,7 +285,7 @@ export function buildTelegramModelSwitchContinuationText(telegramPrefix, model,
 }
 export function buildTelegramModelSwitchContinuationTurn(options) {
     const modelLabel = `${options.selection.model.provider}/${options.selection.model.id}`;
-    const statusLabel = truncateTelegramModelSwitchStatusSummary(`continue on ${options.selection.model.id}`);
+    const statusLabel = truncateTelegramQueueSummary(`continue on ${options.selection.model.id}`, 4, 32);
     return {
         kind: "prompt",
         chatId: options.turn.chatId,