@llblab/pi-telegram 0.52.2 → 0.53.0

package/dist/lib/logging.js

@@ -3,10 +3,10 @@
  * Zones: telegram diagnostics, filesystem, session observability
  * Owns bounded JSONL runtime evidence files, previous-log preservation, and profile-aware log paths without becoming routing state
  */
-import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync, appendFileSync, } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { resolveAgentDir, resolveTelegramProfileTempFilePath, resolveTelegramRuntimeLogPath, resolveTelegramPreviousSharedRuntimeLogPath, } from "./paths.js";
 import { withTelegramFileTransaction } from "./locks.js";
+import { resolveAgentDir, resolveTelegramPreviousSharedRuntimeLogPath, resolveTelegramProfileTempFilePath, resolveTelegramRuntimeLogPath, } from "./paths.js";
 import * as Status from "./status.js";
 const DEFAULT_MAX_LOG_BYTES = 5 * 1024 * 1024;
 export function getTelegramRuntimeLogPath(agentDir = resolveAgentDir(), profileName) {
@@ -27,7 +27,9 @@ function safeJsonLine(value) {
     });
 }
 export function createTelegramRuntimeJsonlLog(options = {}) {
-    const shared = options.sharedProfiles ? { ...options.sharedProfiles } : undefined;
+    const shared = options.sharedProfiles
+        ? { ...options.sharedProfiles }
+        : undefined;
     const pathSource = options.path, previousSource = options.previousPath;
     const canReset = options.canReset, commitReset = options.commitReset;
     const resolvePath = () => typeof pathSource === "function"
@@ -38,7 +40,8 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
             return previousSource();
         if (previousSource)
             return previousSource;
-        return shared ? join(dirname(resolvePath()), "logs", `${basename(resolvePath(), ".jsonl")}._prev.jsonl`)
+        return shared
+            ? join(dirname(resolvePath()), "logs", `${basename(resolvePath(), ".jsonl")}._prev.jsonl`)
             : resolvePath().replace(/\.jsonl$/u, "._prev.jsonl");
     };
     const maxBytes = options.maxBytes ?? DEFAULT_MAX_LOG_BYTES;
@@ -48,12 +51,17 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
     let appendScheduled = false;
     let queuedAppends = [];
     const getProfile = () => shared?.getProfileName() ?? "default";
-    const transactionPath = (path) => shared ? join(dirname(path), "runtime", `${basename(path)}.transaction`) : `${path}.transaction`;
+    const transactionPath = (path) => shared
+        ? join(dirname(path), "runtime", `${basename(path)}.transaction`)
+        : `${path}.transaction`;
     const captureRotation = (path, previousPath, profile) => {
         if (!shared)
             return undefined;
         const authority = shared.captureAuthority();
-        return () => authority?.() === true && resolvePath() === path && resolvePreviousPath() === previousPath && getProfile() === profile;
+        return () => authority?.() === true &&
+            resolvePath() === path &&
+            resolvePreviousPath() === previousPath &&
+            getProfile() === profile;
     };
     const scopeStorageKey = (path, profile) => shared ? JSON.stringify([path, profile]) : path;
     const ensureParent = (path) => {
@@ -94,11 +102,18 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
                 if (shared && !isCurrent?.())
                     return;
                 if (shared) {
-                    const line = safeJsonLine({ at: getNowMs(), kind: "reset", reason, scope, profile }) + "\n";
+                    const line = safeJsonLine({
+                        at: getNowMs(),
+                        kind: "reset",
+                        reason,
+                        scope,
+                        profile,
+                    }) + "\n";
                     if (!isCurrent?.())
                         return;
                     ensureParent(path);
-                    if (existsSync(path) && statSync(path).size + Buffer.byteLength(line) > maxBytes &&
+                    if (existsSync(path) &&
+                        statSync(path).size + Buffer.byteLength(line) > maxBytes &&
                         !writeResetLocked(path, previousPath, "max-bytes", { maxBytes }, profile, isCurrent))
                         return;
                     if (!isCurrent?.())
@@ -121,8 +136,17 @@ export function createTelegramRuntimeJsonlLog(options = {}) {
     const appendEvent = (event) => {
         const path = resolvePath(), previousPath = resolvePreviousPath(), profile = getProfile();
         const rotationCurrent = captureRotation(path, previousPath, profile);
-        const line = safeJsonLine({ kind: "event", ...event, ...(shared ? { profile } : {}) }) + "\n";
-        queuedAppends.push({ path, previousPath, line, ...(shared ? { profile, rotationCurrent } : {}) });
+        const line = safeJsonLine({
+            kind: "event",
+            ...event,
+            ...(shared ? { profile } : {}),
+        }) + "\n";
+        queuedAppends.push({
+            path,
+            previousPath,
+            line,
+            ...(shared ? { profile, rotationCurrent } : {}),
+        });
         if (appendScheduled)
             return;
         appendScheduled = true;
@@ -244,10 +268,20 @@ export function createTelegramRuntimeDiagnosticsRuntime(options = {}) {
         getBotToken: () => getBotToken(),
     });
     const jsonl = createTelegramRuntimeJsonlLog({
-        path: () => sharedFile ? resolveTelegramRuntimeLogPath() : getTelegramRuntimeLogPath(undefined, getProfileName()),
-        previousPath: () => sharedFile ? resolveTelegramPreviousSharedRuntimeLogPath()
+        path: () => sharedFile
+            ? resolveTelegramRuntimeLogPath()
+            : getTelegramRuntimeLogPath(undefined, getProfileName()),
+        previousPath: () => sharedFile
+            ? resolveTelegramPreviousSharedRuntimeLogPath()
             : getTelegramPreviousRuntimeLogPath(undefined, getProfileName()),
-        ...(sharedFile ? { sharedProfiles: { getProfileName: () => getProfileName(), captureAuthority: () => captureAuthority() } } : {}),
+        ...(sharedFile
+            ? {
+                sharedProfiles: {
+                    getProfileName: () => getProfileName(),
+                    captureAuthority: () => captureAuthority(),
+                },
+            }
+            : {}),
         canReset: () => canReset(),
         commitReset: (commit) => commitReset(commit),
     });
@@ -283,7 +317,9 @@ export function createTelegramRuntimeDiagnosticsRuntime(options = {}) {
             await ports.persistSnapshot(snapshot);
         },
         recordError(error) {
-            events.record("telegram", error, { phase: "runtime-diagnostics-snapshot-persist" });
+            events.record("telegram", error, {
+                phase: "runtime-diagnostics-snapshot-persist",
+            });
         },
     });
     const updateRuntimeLogScope = function (reason) {

package/dist/lib/media.d.ts

@@ -180,7 +180,6 @@ export declare function guessMediaType(path: string): string | undefined;
 export declare function extractTelegramMessageText(message: TelegramMediaMessage): string;
 export declare function extractTelegramForwardContextText(message: TelegramMediaMessage, allowedUserId?: number): string;
 export declare function buildTelegramReplyContextBlock(message: TelegramMediaMessage, replyFiles?: Pick<DownloadedTelegramFile, "path">[], replyOutputs?: readonly string[]): string;
-export declare function extractTelegramMessagePromptText(message: TelegramMediaMessage): string;
 export declare function extractTelegramMessagesText(messages: TelegramMediaMessage[]): string;
 export declare function extractTelegramMessagesPromptText(messages: TelegramMediaMessage[]): string;
 export declare function extractFirstTelegramMessageText(messages: TelegramMediaMessage[]): string;
@@ -197,8 +196,30 @@ export declare function queueTelegramMediaGroupMessage<TMessage extends Telegram
     clearTimer: (timer: ReturnType<typeof setTimeout>) => void;
     dispatchMessages: (messages: TMessage[], ctx?: TContext) => unknown | Promise<unknown>;
 }): boolean;
+/** Timer and dispatch lifecycle shared by delayed media-group and text-group coalescing. */
+export interface TelegramPendingGroupState<TMessage, TContext> {
+    messages: TMessage[];
+    context?: TContext;
+    flushTimer?: ReturnType<typeof setTimeout>;
+    dispatching?: boolean;
+    suspended?: boolean;
+    reschedule?: () => void;
+    dispatchNow?: () => Promise<void>;
+}
+export interface TelegramPendingGroupLifecycle<TContext> {
+    flushMessage: (messageId: number) => Promise<boolean>;
+    suspend: () => void;
+    resume: (context: TContext) => void;
+    clear: () => void;
+}
+export declare function createTelegramPendingGroupLifecycle<TMessage extends {
+    message_id: number;
+}, TContext>(groups: Map<string, TelegramPendingGroupState<TMessage, TContext>>, clearTimer: (timer: ReturnType<typeof setTimeout>) => void): TelegramPendingGroupLifecycle<TContext>;
 export declare function createTelegramMediaGroupController<TMessage extends TelegramMediaGroupMessage, TContext = unknown>(options?: TelegramMediaGroupControllerOptions): TelegramMediaGroupController<TMessage, TContext>;
 export declare function createTelegramMediaGroupDispatchRuntime<TMessage extends TelegramMediaGroupMessage, TContext>(deps: TelegramMediaGroupDispatchRuntimeDeps<TMessage, TContext>): TelegramMediaGroupDispatchRuntime<TMessage, TContext>;
+/** Pure `[title]` bullet section appended after a blank line; empty items leave text unchanged. */
+export declare function appendTelegramListSection(text: string, title: string, items: string[]): string;
+export declare function appendTelegramAttachmentSection(text: string, files: Pick<DownloadedTelegramFile, "path">[]): string;
 export declare function formatTelegramHistoryText(rawText: string, files: DownloadedTelegramFile[], handlerOutputs?: string[]): string;
 export declare function downloadTelegramMessageFiles(messages: TelegramMediaMessage[], deps: DownloadTelegramMessageFilesDeps): Promise<DownloadedTelegramMessageFile[]>;
 export declare function collectTelegramFileInfos(messages: TelegramMediaMessage[]): TelegramFileInfo[];

package/dist/lib/media.js

@@ -200,9 +200,6 @@ function appendTelegramReplyContext(text, replyContext) {
         return text;
     return text ? `${text}\n\n${replyContext}` : `_\n\n${replyContext}`;
 }
-export function extractTelegramMessagePromptText(message) {
-    return appendTelegramReplyContext(extractTelegramMessageText(message), buildTelegramReplyContextBlock(message));
-}
 export function extractTelegramMessagesText(messages) {
     return messages.map(extractTelegramMessageText).filter(Boolean).join("\n\n");
 }
@@ -317,23 +314,8 @@ export function queueTelegramMediaGroupMessage(options) {
     options.groups.set(key, existing);
     return true;
 }
-export function createTelegramMediaGroupController(options = {}) {
-    const groups = new Map();
-    const debounceMs = options.debounceMs ?? TELEGRAM_MEDIA_GROUP_DEBOUNCE_MS;
-    const setTimer = options.setTimer ??
-        ((callback, ms) => setTimeout(callback, ms));
-    const clearTimer = options.clearTimer ?? clearTimeout;
+export function createTelegramPendingGroupLifecycle(groups, clearTimer) {
     return {
-        queueMessage: ({ message, context, dispatchMessages }) => queueTelegramMediaGroupMessage({
-            message,
-            context,
-            groups,
-            debounceMs,
-            setTimer,
-            clearTimer,
-            dispatchMessages,
-        }),
-        removeMessages: (messageIds) => removePendingTelegramMediaGroupMessages(groups, messageIds, clearTimer),
         async flushMessage(messageId) {
             for (const state of groups.values()) {
                 if (!state.messages.some((message) => message.message_id === messageId)) {
@@ -376,6 +358,26 @@ export function createTelegramMediaGroupController(options = {}) {
         },
     };
 }
+export function createTelegramMediaGroupController(options = {}) {
+    const groups = new Map();
+    const debounceMs = options.debounceMs ?? TELEGRAM_MEDIA_GROUP_DEBOUNCE_MS;
+    const setTimer = options.setTimer ??
+        ((callback, ms) => setTimeout(callback, ms));
+    const clearTimer = options.clearTimer ?? clearTimeout;
+    return {
+        queueMessage: ({ message, context, dispatchMessages }) => queueTelegramMediaGroupMessage({
+            message,
+            context,
+            groups,
+            debounceMs,
+            setTimer,
+            clearTimer,
+            dispatchMessages,
+        }),
+        removeMessages: (messageIds) => removePendingTelegramMediaGroupMessages(groups, messageIds, clearTimer),
+        ...createTelegramPendingGroupLifecycle(groups, clearTimer),
+    };
+}
 export function createTelegramMediaGroupDispatchRuntime(deps) {
     return {
         handleMessage: async (message, ctx) => {
@@ -394,13 +396,14 @@ export function createTelegramMediaGroupDispatchRuntime(deps) {
         },
     };
 }
-function appendTelegramListSection(text, title, items) {
+/** Pure `[title]` bullet section appended after a blank line; empty items leave text unchanged. */
+export function appendTelegramListSection(text, title, items) {
     if (items.length === 0)
         return text;
     const prefix = text.length > 0 ? `${text}\n\n` : "";
     return `${prefix}[${title}]\n${items.map((item) => `- ${item}`).join("\n")}`;
 }
-function appendTelegramAttachmentSection(text, files) {
+export function appendTelegramAttachmentSection(text, files) {
     if (files.length === 0)
         return text;
     const dirs = [...new Set(files.map((file) => dirname(file.path)))];
@@ -537,7 +540,9 @@ export function collectTelegramFileInfos(messages) {
             files.push({
                 file_id: message.document.file_id,
                 fileName,
-                ...(message.document.file_name ? { userFileName: message.document.file_name } : {}),
+                ...(message.document.file_name
+                    ? { userFileName: message.document.file_name }
+                    : {}),
                 mimeType: message.document.mime_type,
                 kind: "document",
                 isImage: isImageMimeType(message.document.mime_type),
@@ -549,7 +554,9 @@ export function collectTelegramFileInfos(messages) {
             files.push({
                 file_id: message.video.file_id,
                 fileName,
-                ...(message.video.file_name ? { userFileName: message.video.file_name } : {}),
+                ...(message.video.file_name
+                    ? { userFileName: message.video.file_name }
+                    : {}),
                 mimeType: message.video.mime_type,
                 kind: "video",
                 isImage: false,
@@ -562,7 +569,9 @@ export function collectTelegramFileInfos(messages) {
             files.push({
                 file_id: message.audio.file_id,
                 fileName,
-                ...(message.audio.file_name ? { userFileName: message.audio.file_name } : {}),
+                ...(message.audio.file_name
+                    ? { userFileName: message.audio.file_name }
+                    : {}),
                 mimeType: message.audio.mime_type,
                 kind: "audio",
                 isImage: false,
@@ -584,7 +593,9 @@ export function collectTelegramFileInfos(messages) {
             files.push({
                 file_id: message.animation.file_id,
                 fileName,
-                ...(message.animation.file_name ? { userFileName: message.animation.file_name } : {}),
+                ...(message.animation.file_name
+                    ? { userFileName: message.animation.file_name }
+                    : {}),
                 mimeType: message.animation.mime_type,
                 kind: "animation",
                 isImage: false,
@@ -598,16 +609,23 @@ export function collectTelegramFileInfos(messages) {
             files.push({
                 file_id: message.sticker.file_id,
                 fileName: `sticker-${message.message_id}${extension}`,
-                mimeType: video ? "video/webm" : animated ? "application/x-tgsticker" : "image/webp",
+                mimeType: video
+                    ? "video/webm"
+                    : animated
+                        ? "application/x-tgsticker"
+                        : "image/webp",
                 kind: "sticker",
                 isImage: !video && !animated,
             });
         }
         for (const file of files.slice(firstOfMessage)) {
-            file.source = { kind: file.kind, messageId: message.message_id,
+            file.source = {
+                kind: file.kind,
+                messageId: message.message_id,
                 ...(file.index !== undefined ? { index: file.index } : {}),
                 ...(file.userFileName ? { userFileName: file.userFileName } : {}),
-                ...(message.chat ? { chat: message.chat } : {}) };
+                ...(message.chat ? { chat: message.chat } : {}),
+            };
         }
     }
     const seenFileIds = new Set();

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

@@ -5,6 +5,8 @@
  */
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 import { type MenuModel, type ScopedTelegramModel, type TelegramModelSwitchContinuationSource, type ThinkingLevel } from "./model.ts";
+import type { TelegramTarget } from "./target.ts";
+import { type TelegramApiCallOptions } from "./telegram-api.ts";
 export type TelegramModelScope = "all" | "scoped";
 export interface TelegramModelMenuState<TModel extends MenuModel = MenuModel> {
     chatId: number;
@@ -79,12 +81,20 @@ export type TelegramReplyMarkup = TelegramInlineKeyboardMarkup;
 export interface TelegramMenuMessageRuntimeDeps {
     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>;
+        target?: TelegramTarget;
+    } & Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<number | undefined>;
 }
+/** Per-open delivery lifetime; never retain this guard in stored callback state. */
+export declare function createTelegramMenuDelivery<TModel extends MenuModel>(target: TelegramTarget, options: Pick<TelegramApiCallOptions, "assertAuthority"> | undefined, deps: Pick<TelegramMenuMessageRuntimeDeps, "sendInteractiveMessage"> & {
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+}): {
+    assertCurrent: () => void;
+    assertAuthority: (() => void) | undefined;
+    sendInteractiveMessage: (chatId: number, text: string, mode: "html" | "markdown" | "plain", replyMarkup: TelegramInlineKeyboardMarkup, options?: ({
+        target?: TelegramTarget;
+    } & Pick<TelegramApiCallOptions, "assertAuthority">) | undefined) => Promise<number | undefined>;
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+};
 export type TelegramModelMenuCallbackDeps<TModel extends MenuModel = MenuModel> = {
     answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
     updateModelMenuMessage: () => Promise<void>;
@@ -177,6 +187,10 @@ export interface TelegramModelMenuRuntime<TModel extends MenuModel = MenuModel>
 export declare const TELEGRAM_MODEL_PAGE_SIZE = 6;
 export declare const MODEL_MENU_TITLE = "<b>\uD83E\uDD16 Choose a model:</b>";
 export declare const MODEL_PAGE_MENU_TITLE = "<b>Choose a page:</b>";
+/** Apply the payload mode to state, then edit the existing menu message in place. */
+export declare function editTelegramMenuMessage(state: TelegramModelMenuState, payload: TelegramMenuRenderPayload, deps: TelegramMenuMessageRuntimeDeps): Promise<void>;
+/** Apply the payload mode to state, then send a fresh menu message to its exact chat/Thread. */
+export declare function sendTelegramMenuMessage(state: TelegramModelMenuState, payload: TelegramMenuRenderPayload, deps: TelegramMenuMessageRuntimeDeps): Promise<number | undefined>;
 export declare function formatScopedModelButtonText<TModel extends MenuModel = MenuModel>(entry: ScopedTelegramModel<TModel>, currentModel: TModel | undefined): string;
 export declare function formatStatusButtonLabel(label: string, value: string): string;
 export declare function getModelMenuItems<TModel extends MenuModel = MenuModel>(state: TelegramModelMenuState<TModel>): ScopedTelegramModel<TModel>[];

package/dist/lib/menu-model.js

@@ -4,9 +4,49 @@
  * Owns model-menu state, scoped model pages, model callback planning, and model-menu message rendering
  */
 import { getCanonicalModelId, modelsMatch, parseTelegramCliScopedModelPatterns, resolveScopedModelPatterns, sortScopedModels, } from "./model.js";
+import { TelegramApiAuthorityError, } from "./telegram-api.js";
 const TELEGRAM_MODEL_MENU_CACHE_TTL_MS = 5000;
 const TELEGRAM_MODEL_MENU_STATE_TTL_MS = 10 * 60 * 1000;
 const MAX_STORED_TELEGRAM_MODEL_MENUS = 50;
+/** Per-open delivery lifetime; never retain this guard in stored callback state. */
+export function createTelegramMenuDelivery(target, options, deps) {
+    const assertAuthority = options?.assertAuthority, capturedTarget = { ...target };
+    const sendInteractiveMessage = deps.sendInteractiveMessage, storeModelMenuState = deps.storeModelMenuState;
+    let requestIssued = false;
+    const assertCurrent = () => {
+        try {
+            assertAuthority?.();
+        }
+        catch {
+            throw new TelegramApiAuthorityError(requestIssued);
+        }
+    };
+    assertCurrent();
+    return {
+        assertCurrent,
+        assertAuthority,
+        sendInteractiveMessage: async (...args) => {
+            assertCurrent();
+            const [chatId, text, mode, replyMarkup, sendOptions] = args;
+            const messageId = await sendInteractiveMessage(assertAuthority ? capturedTarget.chatId : chatId, text, mode, replyMarkup, assertAuthority
+                ? { ...sendOptions, target: { ...capturedTarget }, assertAuthority }
+                : sendOptions);
+            requestIssued = true;
+            assertCurrent();
+            return messageId;
+        },
+        storeModelMenuState: (state) => {
+            assertCurrent();
+            if (assertAuthority &&
+                (state.chatId !== capturedTarget.chatId ||
+                    state.threadId !== capturedTarget.threadId)) {
+                throw new TelegramApiAuthorityError(requestIssued);
+            }
+            storeModelMenuState(state);
+            assertCurrent();
+        },
+    };
+}
 export const TELEGRAM_MODEL_PAGE_SIZE = 6;
 const TELEGRAM_MODEL_PAGE_PICKER_ROW_SIZE = 4;
 export const MODEL_MENU_TITLE = "<b>🤖 Choose a model:</b>";
@@ -42,11 +82,13 @@ function applyTelegramMenuRenderPayload(state, payload) {
     state.mode = payload.nextMode;
     return payload;
 }
-async function editTelegramMenuMessage(state, payload, deps) {
+/** Apply the payload mode to state, then edit the existing menu message in place. */
+export 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) {
+/** Apply the payload mode to state, then send a fresh menu message to its exact chat/Thread. */
+export 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 } }
@@ -366,7 +408,7 @@ export function buildTelegramModelCallbackPlan(params) {
     if (action.action === "open") {
         const detailResult = applyTelegramModelDetailSelection(params.state, action.value);
         if (detailResult === "invalid") {
-            return { kind: "answer", text: "Selected model is no longer available." };
+            return { kind: "answer", text: "Selected model is no longer available" };
         }
         return { kind: "update-menu" };
     }
@@ -376,12 +418,12 @@ export function buildTelegramModelCallbackPlan(params) {
         if (params.state.canMutateScope === false) {
             return {
                 kind: "answer",
-                text: "Model scope is controlled by CLI --models.",
+                text: "Model scope is controlled by CLI --models",
             };
         }
         const selectionResult = getTelegramSelectedDetailModel(params.state);
         if (selectionResult.kind !== "selected") {
-            return { kind: "answer", text: "Selected model is no longer available." };
+            return { kind: "answer", text: "Selected model is no longer available" };
         }
         const model = selectionResult.selection.model;
         const enabled = action.action === "scope-toggle"
@@ -406,10 +448,10 @@ export function buildTelegramModelCallbackPlan(params) {
         ? getTelegramSelectedDetailModel(params.state)
         : getTelegramModelSelection(params.state, action.value);
     if (selectionResult.kind === "invalid") {
-        return { kind: "answer", text: "Invalid model selection." };
+        return { kind: "answer", text: "Invalid model selection" };
     }
     if (selectionResult.kind === "missing") {
-        return { kind: "answer", text: "Selected model is no longer available." };
+        return { kind: "answer", text: "Selected model is no longer available" };
     }
     const selection = selectionResult.selection;
     if (modelsMatch(selection.model, params.activeModel)) {
@@ -428,7 +470,7 @@ export function buildTelegramModelCallbackPlan(params) {
         if (!params.canRestartBusyRun) {
             return {
                 kind: "answer",
-                text: "Pi is busy. Send /abort, /next, or /stop.",
+                text: "Pi is busy. Send /abort, /next, or /stop",
             };
         }
         return {
@@ -481,7 +523,7 @@ export async function handleTelegramModelMenuCallbackAction(callbackQueryId, par
     }
     if (plan.kind === "persist-scope") {
         if (!deps.persistScopedModelPatterns) {
-            await deps.answerCallbackQuery(callbackQueryId, "Scoped model persistence is unavailable.");
+            await deps.answerCallbackQuery(callbackQueryId, "Scoped model persistence is unavailable");
             return true;
         }
         await deps.persistScopedModelPatterns(plan.patterns);
@@ -499,7 +541,7 @@ export async function handleTelegramModelMenuCallbackAction(callbackQueryId, par
     }
     const changed = await deps.setModel(plan.selection.model);
     if (changed === false) {
-        await deps.answerCallbackQuery(callbackQueryId, "Model is not available.");
+        await deps.answerCallbackQuery(callbackQueryId, "Model is not available");
         return true;
     }
     deps.setCurrentModel(plan.selection.model);
@@ -526,7 +568,7 @@ export async function handleTelegramModelMenuCallbackAction(callbackQueryId, par
         const restarted = await deps.restartInterruptedTelegramTurn(plan.selection, continuationTurn);
         await deps.updateModelMenuMessage();
         if (!restarted) {
-            await deps.answerCallbackQuery(callbackQueryId, "Pi is busy. Send /abort, /next, or /stop.");
+            await deps.answerCallbackQuery(callbackQueryId, "Pi is busy. Send /abort, /next, or /stop");
             return true;
         }
     }

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

@@ -4,9 +4,10 @@
  * Owns queue-menu rendering, queue item callbacks, and queue-menu runtime adapters while core queue mechanics stay in queue
  */
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
-import type { TelegramModelMenuState } from "./menu.ts";
+import { type TelegramMenuMessageRuntimeDeps, type TelegramModelMenuState } from "./menu-model.ts";
 import type { MenuModel } from "./model.ts";
 import * as Queue from "./queue.ts";
+import type { TelegramApiCallOptions } from "./telegram-api.ts";
 type TelegramQueueMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 interface TelegramQueueMenuCallbackQuery {
     id: string;
@@ -19,16 +20,16 @@ interface TelegramQueueMenuCallbackQuery {
     };
 }
 interface TelegramQueueMenuRuntime<Context> {
-    openQueueMenu: (chatId: number, replyToMessageId: number, ctx: Context) => Promise<void>;
+    openQueueMenu: (chatId: number, replyToMessageId: number, ctx: Context, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
     handleCallbackQuery: (query: TelegramQueueMenuCallbackQuery, ctx: Context) => Promise<boolean>;
 }
 export declare function createTelegramQueueMenuRuntime<Context, TModel extends MenuModel = MenuModel>(deps: {
     telegramQueueStore: Queue.TelegramQueueStateStore<Context>;
     queueMutationRuntime: Queue.TelegramQueueMutationController<Context>;
-    sendInteractiveMessage: (chatId: number, text: string, mode: "html", replyMarkup: TelegramQueueMenuReplyMarkup) => Promise<number | undefined>;
+    sendInteractiveMessage: TelegramMenuMessageRuntimeDeps["sendInteractiveMessage"];
     editInteractiveMessage: (chatId: number, messageId: number, text: string, mode: "html", replyMarkup: TelegramQueueMenuReplyMarkup) => Promise<void>;
     answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
-    getModelMenuState: (chatId: number, ctx: Context) => Promise<TelegramModelMenuState<TModel>>;
+    getModelMenuState: (chatId: number, ctx: Context, threadId?: number) => Promise<TelegramModelMenuState<TModel>>;
     getStoredModelMenuState: (messageId: number | undefined, chatId?: number) => TelegramModelMenuState<TModel> | undefined;
     storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
     updateStatusMessage: (state: TelegramModelMenuState<TModel>, ctx: Context) => Promise<void>;