@llblab/pi-telegram 0.45.11 → 0.47.0

package/dist/lib/menu-queue.js

@@ -0,0 +1,408 @@
+/**
+ * Telegram queue menu UI helpers
+ * Zones: telegram ui, queue controls, menu composition
+ * Owns queue-menu rendering, queue item callbacks, and queue-menu runtime adapters while core queue mechanics stay in queue
+ */
+// --- Queue Menu ---
+const QUEUE_ITEM_PROMPT_HTML_LIMIT = 3600;
+const QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX = "\n… [truncated]";
+const EMPTY_QUEUE_REFRESH_TITLES = [
+    "<b>⌛ Queue is still empty</b>",
+    "<b>🫙 Still nothing in queue</b>",
+    "<b>🍃 Queue remains empty</b>",
+    "<b>🕳 Nothing queued yet</b>",
+    "<b>🦗 Queue crickets continue</b>",
+    "<b>🌙 Queue is peacefully idle</b>",
+    "<b>🧘 Nothing waiting. Very zen</b>",
+    "<b>🪐 Queue orbit is clear</b>",
+    "<b>🧺 Basket is empty</b>",
+    "<b>🔭 No prompts on the horizon</b>",
+    "<b>🫧 Queue bubbles: none</b>",
+    "<b>🛸 No queued signals detected</b>",
+];
+function getTelegramQueueItemPromptText(item) {
+    if (item.kind !== "prompt")
+        return item.statusSummary;
+    return (item.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n")
+        .trim() || item.statusSummary);
+}
+function toTelegramQueueMenuItems(items) {
+    return items.map((item, index) => {
+        return {
+            chatId: item.chatId,
+            replyToMessageId: item.replyToMessageId,
+            queuePosition: index + 1,
+            isPriority: item.queueLane === "priority",
+            priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
+            reactionSuppressionEmoji: item.kind === "prompt" ? item.reactionSuppressionEmoji : undefined,
+            hasAttachments: item.kind === "prompt" && item.queuedAttachments.length > 0,
+            statusSummary: item.statusSummary,
+            promptText: getTelegramQueueItemPromptText(item),
+        };
+    });
+}
+function formatSkippedTelegramQueuePosition(position) {
+    return Array.from(String(position), (char) => `${char}\u0335`).join("");
+}
+function buildTelegramQueueMenuReplyMarkup(items, emptyRefreshIndex = 0) {
+    const backRow = [{ text: "⬆️ Main menu", callback_data: "menu:back" }];
+    const nextEmptyRefreshIndex = (emptyRefreshIndex + 1) % EMPTY_QUEUE_REFRESH_TITLES.length;
+    const refreshData = items.length === 0
+        ? `queue:refresh:${nextEmptyRefreshIndex}`
+        : "queue:refresh";
+    const refreshRow = [{ text: "🔄 Refresh", callback_data: refreshData }];
+    if (items.length === 0)
+        return { inline_keyboard: [backRow, refreshRow] };
+    const rows = items.map((item) => {
+        const prefix = item.reactionSuppressionEmoji
+            ? `${item.reactionSuppressionEmoji} `
+            : item.isPriority
+                ? `${item.priorityEmoji ?? "⚡"} `
+                : item.hasAttachments
+                    ? "📎 "
+                    : "";
+        const position = item.reactionSuppressionEmoji
+            ? formatSkippedTelegramQueuePosition(item.queuePosition)
+            : String(item.queuePosition);
+        const ordinalSeparator = item.reactionSuppressionEmoji ? "\u200A" : "";
+        const label = `${position}${ordinalSeparator}. ${prefix}${item.statusSummary}`;
+        return [
+            {
+                text: label,
+                callback_data: `queue:pick:${item.chatId}:${item.replyToMessageId}`,
+            },
+        ];
+    });
+    return { inline_keyboard: [backRow, refreshRow, ...rows] };
+}
+function findTelegramQueueItem(items, chatId, replyToMessageId) {
+    return items.find((item) => {
+        return item.chatId === chatId && item.replyToMessageId === replyToMessageId;
+    });
+}
+function findTelegramQueueMenuItem(items, chatId, replyToMessageId) {
+    return items.find((item) => {
+        return item.chatId === chatId && item.replyToMessageId === replyToMessageId;
+    });
+}
+function escapeTelegramQueueMenuHtmlChar(char) {
+    if (char === "&")
+        return "&amp;";
+    if (char === "<")
+        return "&lt;";
+    if (char === ">")
+        return "&gt;";
+    return char;
+}
+function escapeTelegramQueueMenuHtml(text) {
+    return Array.from(text).map(escapeTelegramQueueMenuHtmlChar).join("");
+}
+function escapeTelegramQueueMenuHtmlPreview(text) {
+    const suffix = escapeTelegramQueueMenuHtml(QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX);
+    let escaped = "";
+    let truncated = false;
+    for (const char of text) {
+        const next = escapeTelegramQueueMenuHtmlChar(char);
+        if (escaped.length + next.length + suffix.length >
+            QUEUE_ITEM_PROMPT_HTML_LIMIT) {
+            truncated = true;
+            break;
+        }
+        escaped += next;
+    }
+    return truncated ? escaped + suffix : escaped;
+}
+function getTelegramQueueMenuItemText(item) {
+    const badge = item.reactionSuppressionEmoji
+        ? ` ${item.reactionSuppressionEmoji}`
+        : item.isPriority
+            ? ` ${item.priorityEmoji ?? "⚡"}`
+            : "";
+    const position = item.reactionSuppressionEmoji
+        ? `<s>${item.queuePosition}</s>.`
+        : `<b>${item.queuePosition}.</b>`;
+    const heading = `${position}${badge}`;
+    const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
+    return `${heading}\n${preview}`;
+}
+function buildTelegramQueueItemSubmenuReplyMarkup(chatId, replyToMessageId, isPriority, isSkipped) {
+    return {
+        inline_keyboard: [
+            [{ text: "⬆️ Back", callback_data: "queue:list" }],
+            [
+                {
+                    text: isPriority ? "🟡 Priority" : "⚫️ Priority",
+                    callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
+                },
+                {
+                    text: isPriority ? "⚫️ Normal" : "🔵 Normal",
+                    callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
+                },
+            ],
+            [
+                {
+                    text: isSkipped ? "⚫️ Keep" : "🟢 Keep",
+                    callback_data: `queue:skip-set:${chatId}:${replyToMessageId}:keep`,
+                },
+                {
+                    text: isSkipped ? "🔴 Skip" : "⚫️ Skip",
+                    callback_data: `queue:skip-set:${chatId}:${replyToMessageId}:skip`,
+                },
+            ],
+        ],
+    };
+}
+async function handleTelegramQueueMenuCallback(callbackQueryId, data, replyChatId, replyMessageId, ctx, deps) {
+    if (!data.startsWith("queue:"))
+        return false;
+    if (data === "queue:noop") {
+        await deps.answerCallbackQuery(callbackQueryId);
+        return true;
+    }
+    if (data === "queue:list") {
+        await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps);
+        return true;
+    }
+    const refreshMatch = data.match(/^queue:refresh(?::(\d+))?$/);
+    if (refreshMatch) {
+        await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, undefined, refreshMatch[1] === undefined ? 0 : Number(refreshMatch[1]));
+        return true;
+    }
+    const pickMatch = data.match(/^queue:pick:(\d+):(\d+)$/);
+    if (pickMatch) {
+        await handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, Number(pickMatch[1]), Number(pickMatch[2]), deps);
+        return true;
+    }
+    const prioSetMatch = data.match(/^queue:prio-set:(\d+):(\d+):(priority|normal)$/);
+    if (prioSetMatch) {
+        await handleTelegramQueueMenuPrioritySet(callbackQueryId, replyChatId, replyMessageId, Number(prioSetMatch[1]), Number(prioSetMatch[2]), prioSetMatch[3] === "priority", ctx, deps);
+        return true;
+    }
+    const prioMatch = data.match(/^queue:prio:(\d+):(\d+)$/);
+    if (prioMatch) {
+        await handleTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, Number(prioMatch[1]), Number(prioMatch[2]), ctx, deps);
+        return true;
+    }
+    const skipSetMatch = data.match(/^queue:skip-set:(\d+):(\d+):(skip|keep)$/);
+    if (skipSetMatch) {
+        await handleTelegramQueueMenuSkipSet(callbackQueryId, replyChatId, replyMessageId, Number(skipSetMatch[1]), Number(skipSetMatch[2]), skipSetMatch[3] === "skip", ctx, deps);
+        return true;
+    }
+    return false;
+}
+function getTelegramQueueMenuListText(items, emptyRefreshIndex) {
+    if (items.length > 0)
+        return "<b>⏳ Queue:</b>";
+    if (emptyRefreshIndex === undefined)
+        return "<b>⌛ Queue is empty</b>";
+    return EMPTY_QUEUE_REFRESH_TITLES[emptyRefreshIndex % EMPTY_QUEUE_REFRESH_TITLES.length];
+}
+async function updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, notice, emptyRefreshIndex) {
+    const items = deps.getQueuedItems();
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuListText(items, emptyRefreshIndex), buildTelegramQueueMenuReplyMarkup(items, emptyRefreshIndex));
+    await deps.answerCallbackQuery(callbackQueryId, notice);
+}
+async function refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps) {
+    await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, "Item no longer in queue.");
+}
+async function handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, deps) {
+    const item = deps.findItem(chatId, msgId);
+    if (!item) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, item.isPriority, item.reactionSuppressionEmoji !== undefined));
+    await deps.answerCallbackQuery(callbackQueryId);
+}
+async function handleTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, ctx, deps) {
+    const item = deps.findItem(chatId, msgId);
+    if (!item) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, !item.isPriority, ctx, deps);
+}
+async function handleTelegramQueueMenuPrioritySet(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps) {
+    const item = deps.findItem(chatId, msgId);
+    if (!item) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps);
+}
+async function updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps) {
+    deps.setPriority(chatId, msgId, enabled);
+    deps.updateStatus(ctx);
+    const updated = deps.findItem(chatId, msgId);
+    if (!updated) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, updated.isPriority, updated.reactionSuppressionEmoji !== undefined));
+    await deps.answerCallbackQuery(callbackQueryId, updated.isPriority ? "Prioritized." : "Normal priority.");
+}
+async function handleTelegramQueueMenuSkipSet(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, skipped, ctx, deps) {
+    const item = deps.findItem(chatId, msgId);
+    if (!item) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    deps.setSkipped(chatId, msgId, skipped);
+    deps.updateStatus(ctx);
+    const updated = deps.findItem(chatId, msgId);
+    if (!updated) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, updated.isPriority, updated.reactionSuppressionEmoji !== undefined));
+    await deps.answerCallbackQuery(callbackQueryId);
+}
+export function createTelegramQueueMenuRuntime(deps) {
+    const sendQueueMenuMessage = createQueueMenuSendMessageAdapter(deps.sendInteractiveMessage);
+    const editQueueMenuMessage = createQueueMenuEditMessageAdapter(deps.editInteractiveMessage);
+    return {
+        openQueueMenu: createOpenQueueMenu({
+            getQueuedItems: deps.telegramQueueStore.getQueuedItems,
+            getModelMenuState: deps.getModelMenuState,
+            storeModelMenuState: deps.storeModelMenuState,
+            sendInteractiveMessage: sendQueueMenuMessage,
+        }),
+        handleCallbackQuery: createQueueMenuCallbackHandler({
+            telegramQueueStore: deps.telegramQueueStore,
+            queueMutationRuntime: deps.queueMutationRuntime,
+            editInteractiveMessage: editQueueMenuMessage,
+            getStoredModelMenuState: deps.getStoredModelMenuState,
+            updateStatusMessage: deps.updateStatusMessage,
+            answerCallbackQuery: deps.answerCallbackQuery,
+            updateStatus: deps.updateStatus,
+        }),
+    };
+}
+function createOpenQueueMenu(deps) {
+    return async (chatId, replyToMessageId, ctx) => {
+        const state = await deps.getModelMenuState(chatId, ctx);
+        const menuItems = toTelegramQueueMenuItems(deps.getQueuedItems());
+        const text = getTelegramQueueMenuListText(menuItems);
+        const messageId = await deps.sendInteractiveMessage(chatId, replyToMessageId, text, buildTelegramQueueMenuReplyMarkup(menuItems));
+        if (messageId === undefined)
+            return;
+        state.messageId = messageId;
+        state.mode = "queue";
+        deps.storeModelMenuState(state);
+    };
+}
+function createQueueMenuCallbackHandler(deps) {
+    return async (query, ctx) => {
+        const data = query.data;
+        const chatId = query.message?.chat?.id;
+        const messageId = query.message?.message_id;
+        if (!data || typeof chatId !== "number" || typeof messageId !== "number")
+            return false;
+        if (data === "menu:queue" || data === "status:queue") {
+            const state = deps.getStoredModelMenuState(messageId, chatId);
+            if (!state) {
+                await deps.answerCallbackQuery(query.id, "Interactive message expired.");
+                return true;
+            }
+            const menuItems = toTelegramQueueMenuItems(deps.telegramQueueStore.getQueuedItems());
+            await deps.editInteractiveMessage(chatId, messageId, getTelegramQueueMenuListText(menuItems), buildTelegramQueueMenuReplyMarkup(menuItems));
+            state.mode = "queue";
+            await deps.answerCallbackQuery(query.id);
+            return true;
+        }
+        if (!data.startsWith("queue:"))
+            return false;
+        const getQueueSnapshot = () => {
+            return deps.telegramQueueStore.getQueuedItems();
+        };
+        const toMenuItems = () => {
+            return toTelegramQueueMenuItems(getQueueSnapshot());
+        };
+        const findItem = (cId, rId) => {
+            return findTelegramQueueMenuItem(toMenuItems(), cId, rId);
+        };
+        return handleTelegramQueueMenuCallback(query.id, data, chatId, messageId, ctx, {
+            getQueuedItems: toMenuItems,
+            findItem,
+            togglePriority: (cId, rId) => {
+                return toggleQueuedTelegramPromptPriority(cId, rId, ctx, {
+                    getQueueSnapshot,
+                    queueMutationRuntime: deps.queueMutationRuntime,
+                });
+            },
+            setPriority: (cId, rId, enabled) => {
+                return setQueuedTelegramPromptPriority(cId, rId, enabled, ctx, {
+                    getQueueSnapshot,
+                    queueMutationRuntime: deps.queueMutationRuntime,
+                });
+            },
+            setSkipped: (cId, rId, skipped) => {
+                return setQueuedTelegramPromptSkipped(cId, rId, skipped, ctx, {
+                    getQueueSnapshot,
+                    queueMutationRuntime: deps.queueMutationRuntime,
+                });
+            },
+            updateQueueMessage: deps.editInteractiveMessage,
+            answerCallbackQuery: deps.answerCallbackQuery,
+            updateStatus: deps.updateStatus,
+        });
+    };
+}
+function getQueueMenuReactionDisposition(item, priority, skipped) {
+    if (priority && skipped) {
+        return {
+            kind: "priority-suppressed",
+            priorityEmoji: item.kind === "prompt" ? item.priorityEmoji ?? "⚡" : "⚡",
+            suppressionEmoji: item.kind === "prompt"
+                ? item.reactionSuppressionEmoji ?? "👎"
+                : "👎",
+        };
+    }
+    if (priority) {
+        return {
+            kind: "priority",
+            emoji: item.kind === "prompt" ? item.priorityEmoji ?? "⚡" : "⚡",
+        };
+    }
+    if (skipped) {
+        return {
+            kind: "suppressed",
+            emoji: item.kind === "prompt"
+                ? item.reactionSuppressionEmoji ?? "👎"
+                : "👎",
+        };
+    }
+    return { kind: "default" };
+}
+function toggleQueuedTelegramPromptPriority(chatId, replyToMessageId, ctx, deps) {
+    const item = findTelegramQueueItem(deps.getQueueSnapshot(), chatId, replyToMessageId);
+    if (!item)
+        return false;
+    deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, getQueueMenuReactionDisposition(item, item.queueLane !== "priority", item.kind === "prompt" &&
+        item.reactionSuppressionEmoji !== undefined), ctx);
+    return true;
+}
+function setQueuedTelegramPromptPriority(chatId, replyToMessageId, enabled, ctx, deps) {
+    const item = findTelegramQueueItem(deps.getQueueSnapshot(), chatId, replyToMessageId);
+    if (!item)
+        return false;
+    deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, getQueueMenuReactionDisposition(item, enabled, item.kind === "prompt" &&
+        item.reactionSuppressionEmoji !== undefined), ctx);
+    return true;
+}
+function setQueuedTelegramPromptSkipped(chatId, replyToMessageId, skipped, ctx, deps) {
+    const item = findTelegramQueueItem(deps.getQueueSnapshot(), chatId, replyToMessageId);
+    if (!item || item.kind !== "prompt")
+        return false;
+    deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, getQueueMenuReactionDisposition(item, item.queueLane === "priority", skipped), ctx);
+    return true;
+}
+function createQueueMenuSendMessageAdapter(sendInteractiveMessage) {
+    return (chatId, _replyToMessageId, text, replyMarkup) => {
+        return sendInteractiveMessage(chatId, text, "html", replyMarkup);
+    };
+}
+function createQueueMenuEditMessageAdapter(editInteractiveMessage) {
+    return (chatId, messageId, text, replyMarkup) => {
+        return editInteractiveMessage(chatId, messageId, text, "html", replyMarkup).then(() => {
+            return undefined;
+        });
+    };
+}

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

@@ -0,0 +1,116 @@
+/**
+ * Telegram settings menu UI helpers
+ * Zones: telegram ui, settings controls, menu composition
+ * Owns hidden settings-menu rendering, settings callbacks, and persisted toggle wiring
+ */
+import type { TelegramActivityVerbosity, TelegramAssistantRenderingMode, TelegramTimeMode, TelegramThreadDisplayMode } from "./config.ts";
+import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
+import type { TelegramModelMenuState } from "./menu-model.ts";
+import type { MenuModel } from "./model.ts";
+import { type TelegramSectionRegistry } from "./sections.ts";
+import type { TelegramVoiceReplyMode } from "./voice.ts";
+export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;
+export interface TelegramSettingsStateDeps {
+    getThreadDisplayMode?: () => TelegramThreadDisplayMode | undefined;
+    getThreadDisplayPreview?: (mode: TelegramThreadDisplayMode) => readonly string[];
+    areDraftPreviewsEnabled: () => boolean;
+    getAssistantRenderingMode: () => TelegramAssistantRenderingMode;
+    getActivityVerbosity: () => TelegramActivityVerbosity;
+    getTimeInjectionMode: () => TelegramTimeMode;
+    getVoiceReplyMode: () => TelegramVoiceReplyMode;
+    isVoiceReplyModeConfigured: () => boolean;
+    isAutomaticThreadCleanupEnabled: () => boolean;
+}
+export interface TelegramSettingsMutationDeps extends TelegramSettingsStateDeps {
+    setThreadDisplayMode?: (mode: TelegramThreadDisplayMode) => Promise<void>;
+    setDraftPreviewsEnabled: (enabled: boolean) => Promise<void>;
+    setAssistantRenderingMode: (mode: TelegramAssistantRenderingMode) => Promise<void>;
+    setActivityVerbosity: (verbosity: TelegramActivityVerbosity) => Promise<void>;
+    setVoiceReplyMode: (mode: TelegramVoiceReplyMode | undefined) => Promise<void>;
+    setTimeInjectionMode: (mode: TelegramTimeMode) => Promise<void>;
+    setAutomaticThreadCleanupEnabled: (enabled: boolean) => Promise<void>;
+    reviewInactiveThreads?: () => Promise<{
+        count: number;
+        operationId?: string;
+    }>;
+    cleanInactiveThreads?: (operationId: string) => Promise<{
+        deleted: number;
+        outcomeUnknown: number;
+        blocked?: number;
+        recovery?: "commit-ready" | "deletion-outcome-unknown" | "authority-blocked";
+    }>;
+}
+export interface TelegramSettingsMenuOpenDeps<TModel extends MenuModel = MenuModel> extends TelegramSettingsStateDeps {
+    getModelMenuState: () => Promise<TelegramModelMenuState<TModel>>;
+    sendSettingsMenu: (state: TelegramModelMenuState<TModel>, text: string, replyMarkup: TelegramSettingsMenuReplyMarkup) => Promise<number | undefined>;
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+}
+export interface TelegramSettingsMenuCallbackDeps extends TelegramSettingsMutationDeps {
+    updateSettingsMessage: (text: string, replyMarkup: TelegramSettingsMenuReplyMarkup) => Promise<void>;
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+    sectionRegistry?: TelegramSectionRegistry;
+}
+export interface TelegramSettingsMenuRuntime<TContext> {
+    openSettingsMenu: (chatId: number, replyToMessageId: number, ctx: TContext) => Promise<void>;
+    handleCallbackQuery: (query: {
+        id: string;
+        data?: string;
+        message?: {
+            message_id?: number;
+            message_thread_id?: number;
+            chat?: {
+                id?: number;
+            };
+        };
+    }, ctx: TContext) => Promise<boolean>;
+    updateSettingsMenuMessage: (state: TelegramModelMenuState, ctx: TContext) => Promise<void>;
+}
+export interface TelegramSettingsMenuMessageUpdateDeps extends TelegramSettingsStateDeps {
+    updateSettingsMessage: (text: string, replyMarkup: TelegramSettingsMenuReplyMarkup) => Promise<void>;
+}
+export interface TelegramSettingsMenuRuntimeDeps<TContext, TModel extends MenuModel = MenuModel> extends TelegramSettingsMutationDeps {
+    reloadConfig?: () => Promise<void>;
+    getModelMenuState: (chatId: number, ctx: TContext, threadId?: number) => Promise<TelegramModelMenuState<TModel>>;
+    getStoredModelMenuState: (messageId: number | undefined, chatId?: number) => TelegramModelMenuState<TModel> | undefined;
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+    editInteractiveMessage: (chatId: number, messageId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramSettingsMenuReplyMarkup) => Promise<void>;
+    sendInteractiveMessage: (chatId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramSettingsMenuReplyMarkup) => Promise<number | undefined>;
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+}
+export declare const SETTINGS_MENU_TITLE = "<b>\u2699\uFE0F Settings:</b>";
+export declare const AUTOMATIC_THREAD_CLEANUP_SETTINGS_TITLE = "<b>\uD83E\uDDF9 Thread cleanup:</b>";
+export declare const INACTIVE_THREAD_REVIEW_TITLE = "<b>\uD83D\uDD0E Inactive tabs review:</b>";
+export declare const DRAFT_PREVIEWS_SETTINGS_TITLE = "<b>\uD83D\uDCDD Draft previews:</b>";
+export declare const ASSISTANT_RENDERING_SETTINGS_TITLE = "<b>\uD83E\uDDFE Assistant rendering:</b>";
+export declare const ACTIVITY_VERBOSITY_SETTINGS_TITLE = "<b>\uD83D\uDD2C Activity:</b>";
+export declare const TIME_INJECTION_MODE_SETTINGS_TITLE = "<b>\uD83D\uDD52 Time injection mode:</b>";
+export declare const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>\uD83D\uDC44 Voice reply mode:</b>";
+export declare const THREAD_DISPLAY_SETTINGS_TITLE = "<b>\uD83E\uDDF5 Thread display:</b>";
+export declare function buildTelegramSettingsMenuText(): string;
+export declare function buildThreadDisplaySettingsText(mode: TelegramThreadDisplayMode, preview?: readonly string[]): string;
+export declare function buildAutomaticThreadCleanupSettingsText(enabled: boolean): string;
+export declare function buildInactiveThreadReviewText(count: number): string;
+export declare function buildInactiveThreadReviewReplyMarkup(operationId?: string, canCleanInactiveThreads?: boolean): TelegramSettingsMenuReplyMarkup;
+export declare function buildDraftPreviewsSettingsText(enabled: boolean): string;
+export declare function buildAssistantRenderingSettingsText(mode: TelegramAssistantRenderingMode): string;
+export declare function buildActivityVerbositySettingsText(verbosity: TelegramActivityVerbosity): string;
+export declare function buildVoiceReplyModeSettingsText(mode: TelegramVoiceReplyMode, configured?: boolean): string;
+export declare function buildTimeInjectionModeSettingsText(mode: TelegramTimeMode): string;
+export declare function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled: boolean, assistantRenderingModeOrVoiceReplyMode: TelegramAssistantRenderingMode | TelegramVoiceReplyMode, voiceReplyModeOrTimeInjectionMode: TelegramVoiceReplyMode | TelegramTimeMode, timeInjectionModeOrSectionRegistry?: TelegramTimeMode | TelegramSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured?: TelegramSectionRegistry | boolean, voiceReplyModeConfigured?: boolean, automaticThreadCleanupEnabled?: boolean, activityVerbosity?: TelegramActivityVerbosity, threadDisplayMode?: TelegramThreadDisplayMode): TelegramSettingsMenuReplyMarkup;
+export declare function openTelegramSettingsMenu<TModel extends MenuModel = MenuModel>(deps: TelegramSettingsMenuOpenDeps<TModel>, sectionRegistry?: TelegramSectionRegistry): Promise<void>;
+export declare function buildThreadDisplaySettingsReplyMarkup(mode: TelegramThreadDisplayMode): TelegramSettingsMenuReplyMarkup;
+export declare function buildAutomaticThreadCleanupSettingsReplyMarkup(enabled: boolean, canReviewInactiveThreads?: boolean): TelegramSettingsMenuReplyMarkup;
+export declare function buildDraftPreviewsSettingsReplyMarkup(enabled: boolean): TelegramSettingsMenuReplyMarkup;
+export declare function buildAssistantRenderingSettingsReplyMarkup(mode: TelegramAssistantRenderingMode): TelegramSettingsMenuReplyMarkup;
+export declare function buildActivityVerbositySettingsReplyMarkup(verbosity: TelegramActivityVerbosity): TelegramSettingsMenuReplyMarkup;
+export declare function buildTimeInjectionModeSettingsReplyMarkup(mode: TelegramTimeMode): TelegramSettingsMenuReplyMarkup;
+export declare function buildVoiceReplyModeSettingsReplyMarkup(mode: TelegramVoiceReplyMode, configured?: boolean): TelegramSettingsMenuReplyMarkup;
+export declare function updateTelegramSettingsMenuMessage(deps: TelegramSettingsMenuMessageUpdateDeps, sectionRegistry?: TelegramSectionRegistry): Promise<void>;
+export declare function updateAutomaticThreadCleanupSettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function updateDraftPreviewsSettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function updateAssistantRenderingSettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function updateActivityVerbositySettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function updateTimeInjectionModeSettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function updateVoiceReplyModeSettingsMessage(deps: TelegramSettingsMenuCallbackDeps): Promise<void>;
+export declare function handleTelegramSettingsMenuCallbackAction(callbackQueryId: string, data: string | undefined, deps: TelegramSettingsMenuCallbackDeps): Promise<boolean>;
+export declare function createTelegramSettingsMenuRuntime<TContext, TModel extends MenuModel = MenuModel>(deps: TelegramSettingsMenuRuntimeDeps<TContext, TModel>, sectionRegistry?: TelegramSectionRegistry): TelegramSettingsMenuRuntime<TContext>;