@llblab/pi-telegram 0.45.11 → 0.47.0

package/dist/lib/menu-status.js

@@ -0,0 +1,112 @@
+/**
+ * Telegram status menu UI helpers
+ * Zones: telegram ui, status controls, menu composition
+ * 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 { getCanonicalModelId, } from "./model.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);
+    if (messageId === undefined)
+        return;
+    state.messageId = messageId;
+    state.mode = "status";
+    deps.storeModelMenuState(state);
+}
+export async function handleTelegramStatusMenuCallbackAction(callbackQueryId, data, activeModel, deps) {
+    if (isTelegramStatusMenuCallbackAction(data, "model")) {
+        await deps.updateModelMenuMessage();
+        await deps.answerCallbackQuery(callbackQueryId);
+        return true;
+    }
+    if (isTelegramStatusMenuCallbackAction(data, "settings")) {
+        if (!deps.updateSettingsMenuMessage)
+            return false;
+        await deps.updateSettingsMenuMessage();
+        await deps.answerCallbackQuery(callbackQueryId);
+        return true;
+    }
+    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.");
+        return true;
+    }
+    await deps.updateThinkingMenuMessage();
+    await deps.answerCallbackQuery(callbackQueryId);
+    return true;
+}
+export function buildStatusReplyMarkup(activeModel, currentThinkingLevel, queueItemCount = 0, sectionRegistry, isVoiceReplyActive) {
+    const rows = [];
+    rows.push([
+        {
+            text: formatStatusButtonLabel(`${formatTelegramCommandEmojiPrefix("model")}Model`, activeModel ? getCanonicalModelId(activeModel) : "unknown"),
+            callback_data: "menu:model",
+        },
+    ]);
+    if (activeModel?.reasoning && !isVoiceReplyActive) {
+        rows.push([
+            {
+                text: formatStatusButtonLabel(`${formatTelegramCommandEmojiPrefix("thinking")}Thinking`, currentThinkingLevel),
+                callback_data: "menu:thinking",
+            },
+        ]);
+    }
+    rows.push([
+        {
+            text: `${queueItemCount === 0 ? "⌛" : "⏳"} Queue: ${queueItemCount}`,
+            callback_data: "menu:queue",
+        },
+    ]);
+    if (sectionRegistry) {
+        const sectionRows = getTelegramSectionMainMenuRows(sectionRegistry);
+        for (const row of sectionRows) {
+            rows.push([row]);
+        }
+    }
+    rows.push([
+        {
+            text: "⚙️ Settings",
+            callback_data: "menu:settings",
+        },
+    ]);
+    return { inline_keyboard: rows };
+}
+export function buildTelegramStatusMenuRenderPayload(statusText, activeModel, currentThinkingLevel, queueItemCount = 0, sectionRegistry, isVoiceReplyActive) {
+    return {
+        nextMode: "status",
+        text: statusText,
+        mode: "html",
+        replyMarkup: buildStatusReplyMarkup(activeModel, currentThinkingLevel, queueItemCount, sectionRegistry, isVoiceReplyActive),
+    };
+}
+export async function updateTelegramStatusMessage(state, statusText, activeModel, currentThinkingLevel, deps, queueItemCount = 0, sectionRegistry, isVoiceReplyActive) {
+    await editTelegramMenuMessage(state, buildTelegramStatusMenuRenderPayload(statusText, activeModel, currentThinkingLevel, queueItemCount, sectionRegistry, isVoiceReplyActive), deps);
+}
+export function sendTelegramStatusMessage(state, statusText, activeModel, currentThinkingLevel, deps, queueItemCount = 0, sectionRegistry, isVoiceReplyActive) {
+    return sendTelegramMenuMessage(state, buildTelegramStatusMenuRenderPayload(statusText, activeModel, currentThinkingLevel, queueItemCount, sectionRegistry, isVoiceReplyActive), deps);
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Telegram thinking menu UI helpers
+ * 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 MenuModel, type ThinkingLevel } from "./model.ts";
+export interface TelegramThinkingMenuCallbackDeps {
+    setThinkingLevel: (level: ThinkingLevel) => void;
+    getCurrentThinkingLevel: () => ThinkingLevel;
+    updateStatusMessage: () => Promise<void>;
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+    isVoiceReplyActive?: () => boolean;
+}
+export interface TelegramThinkingMenuOpenDeps<TModel extends MenuModel = MenuModel> extends TelegramMenuMessageRuntimeDeps {
+    getModelMenuState: () => Promise<TelegramModelMenuState<TModel>>;
+    getActiveModel: () => TModel | undefined;
+    getThinkingLevel: () => ThinkingLevel;
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+    isVoiceReplyActive?: () => 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;
+export declare function buildTelegramThinkingMenuRenderPayload(_activeModel: MenuModel | undefined, currentThinkingLevel: ThinkingLevel): TelegramMenuRenderPayload;
+export declare function openTelegramThinkingMenu<TModel extends MenuModel = MenuModel>(deps: TelegramThinkingMenuOpenDeps<TModel>): Promise<void>;
+export declare function updateTelegramThinkingMenuMessage(state: TelegramModelMenuState, activeModel: MenuModel | undefined, currentThinkingLevel: ThinkingLevel, deps: TelegramMenuMessageRuntimeDeps & {
+    isVoiceReplyActive?: () => boolean;
+}): Promise<void>;

package/dist/lib/menu-thinking.js

@@ -0,0 +1,82 @@
+/**
+ * Telegram thinking menu UI helpers
+ * Zones: telegram ui, thinking controls, menu composition
+ * Owns thinking-menu text, reply markup, callback handling, and thinking-menu message rendering
+ */
+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);
+}
+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.");
+        return true;
+    }
+    if (!activeModel?.reasoning) {
+        await deps.answerCallbackQuery(callbackQueryId, "This model has no reasoning controls.");
+        return true;
+    }
+    deps.setThinkingLevel(action.level);
+    await deps.updateStatusMessage();
+    await deps.answerCallbackQuery(callbackQueryId, `Thinking: ${deps.getCurrentThinkingLevel()}`);
+    return true;
+}
+export function buildThinkingMenuText() {
+    return "<b>🧠 Choose a thinking level:</b>";
+}
+export function buildThinkingMenuReplyMarkup(currentThinkingLevel) {
+    const rows = [[{ text: "⬆️ Main menu", callback_data: "menu:back" }]];
+    const levelButtons = THINKING_LEVELS.map((level) => ({
+        text: level === currentThinkingLevel ? `🟢 ${level}` : level,
+        callback_data: `thinking:set:${level}`,
+    }));
+    rows.push(levelButtons.slice(0, 1), levelButtons.slice(1, 4), levelButtons.slice(4, 7));
+    return { inline_keyboard: rows };
+}
+export function buildTelegramThinkingMenuRenderPayload(_activeModel, currentThinkingLevel) {
+    return {
+        nextMode: "thinking",
+        text: buildThinkingMenuText(),
+        mode: "html",
+        replyMarkup: buildThinkingMenuReplyMarkup(currentThinkingLevel),
+    };
+}
+export async function openTelegramThinkingMenu(deps) {
+    if (deps.isVoiceReplyActive?.())
+        return;
+    const state = await deps.getModelMenuState();
+    const messageId = await sendTelegramMenuMessage(state, buildTelegramThinkingMenuRenderPayload(deps.getActiveModel(), deps.getThinkingLevel()), deps);
+    if (messageId === undefined)
+        return;
+    state.messageId = messageId;
+    state.mode = "thinking";
+    deps.storeModelMenuState(state);
+}
+export async function updateTelegramThinkingMenuMessage(state, activeModel, currentThinkingLevel, deps) {
+    if (deps.isVoiceReplyActive?.())
+        return;
+    await editTelegramMenuMessage(state, buildTelegramThinkingMenuRenderPayload(activeModel, currentThinkingLevel), deps);
+}

package/dist/lib/menu.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Telegram menu and inline-keyboard rendering helpers
+ * 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 MenuModel, type ScopedTelegramModel, type ThinkingLevel } from "./model.ts";
+import type { TelegramInputRichMessage } from "./telegram-api.ts";
+import { type TelegramSectionRegistry } from "./sections.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";
+export type { TelegramStatusMenuCallbackDeps, TelegramStatusMenuOpenDeps, } from "./menu-status.ts";
+export { buildTelegramThinkingMenuRenderPayload, buildThinkingMenuReplyMarkup, buildThinkingMenuText, handleTelegramThinkingMenuCallbackAction, openTelegramThinkingMenu, updateTelegramThinkingMenuMessage, } from "./menu-thinking.ts";
+export type { TelegramThinkingMenuCallbackDeps, TelegramThinkingMenuOpenDeps, } from "./menu-thinking.ts";
+export interface TelegramMenuCallbackEntryDeps {
+    handleStatusAction: () => Promise<boolean>;
+    handleThinkingAction: () => Promise<boolean>;
+    handleModelAction: () => Promise<boolean>;
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+}
+export interface MenuCallbackQuery {
+    id: string;
+    data?: string;
+    message?: {
+        message_id?: number;
+        message_thread_id?: number;
+        chat?: {
+            id?: number;
+        };
+    };
+}
+export interface StoredTelegramMenuCallbackDeps<TModel extends MenuModel = MenuModel> {
+    getStoredModelMenuState: (messageId: number | undefined, chatId?: number) => TelegramModelMenuState<TModel> | undefined;
+    handleStatusAction: (state: TelegramModelMenuState<TModel>) => Promise<boolean>;
+    handleThinkingAction: (state: TelegramModelMenuState<TModel>) => Promise<boolean>;
+    handleModelAction: (state: TelegramModelMenuState<TModel>) => Promise<boolean>;
+    answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
+}
+export interface TelegramMenuCallbackRuntimeDeps<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) => 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;
+    hasActiveTelegramTurn: () => boolean;
+    hasAbortHandler: () => boolean;
+    hasActiveToolExecutions: () => boolean;
+    persistScopedModelPatterns?: (patterns: string[], ctx: TContext) => Promise<void>;
+    setModel: (model: TModel) => Promise<boolean>;
+    setCurrentModel: (model: TModel, ctx: TContext) => void;
+    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => void;
+    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => 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>;
+    isVoiceReplyActive?: () => boolean;
+}
+export interface TelegramMenuActionRuntimeDeps<TContext, TModel extends MenuModel = MenuModel> extends TelegramMenuMessageRuntimeDeps {
+    getModelMenuState: (chatId: number, ctx: TContext, threadId?: number) => Promise<TelegramModelMenuState<TModel>>;
+    getActiveModel: (ctx: TContext) => TModel | undefined;
+    getThinkingLevel: () => ThinkingLevel;
+    getQueueItemCount?: () => number;
+    buildStatusHtml: (ctx: TContext) => string;
+    storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
+    isIdle: (ctx: TContext) => boolean;
+    canOfferInFlightModelSwitch: (ctx: TContext) => boolean;
+    sendTextReply: (chatId: number, replyToMessageId: number, text: string, options?: {
+        target?: {
+            chatId: number;
+            threadId?: number;
+        };
+        parseMode?: "HTML";
+    }) => Promise<unknown>;
+    sectionRegistry?: TelegramSectionRegistry;
+    isVoiceReplyActive?: () => boolean;
+}
+export interface TelegramMenuActionRuntime<TContext, TModel extends MenuModel = 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>;
+}
+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;
+    hasActiveTelegramTurn: () => boolean;
+    hasAbortHandler: () => boolean;
+    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) => void;
+    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => 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>;