@grinev/opencode-telegram-bot 0.4.0 → 0.6.0

package/.env.example

@@ -39,6 +39,17 @@ OPENCODE_MODEL_ID=big-pickle
 # Bot locale: en or ru (default: en)
 # BOT_LOCALE=en
 
+# Service message batching interval in seconds (thinking + tool calls, default: 5)
+# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
+# 0 = send immediately (can hit rate limits if there are many tool calls)
+# SERVICE_MESSAGES_INTERVAL_SEC=5
+
+# Hide thinking indicator messages (default: false)
+# HIDE_THINKING_MESSAGES=false
+
+# Hide tool call service messages (default: false)
+# HIDE_TOOL_CALL_MESSAGES=false
+
 # Code File Settings (optional)
 # Maximum file size in KB to send as document (default: 100)
 # CODE_FILE_MAX_SIZE_KB=100

package/README.md

@@ -100,7 +100,15 @@ opencode-telegram config
 | `/opencode_stop`  | Stop the OpenCode server remotely                       |
 | `/help`           | Show available commands                                 |
 
-Any regular text message is sent as a prompt to the coding agent.
+Any regular text message is sent as a prompt to the coding agent only when no blocking interaction is active.
+
+### Interaction Rules
+
+- Only one interactive flow can be active at a time (inline menus, permission request, question flow, rename)
+- While an interaction is active, the bot accepts only relevant input for that flow and blocks unrelated actions
+- Allowed utility commands remain available during active interactions: `/help`, `/status`, `/stop`
+- Unknown slash commands return an explicit fallback message instead of being silently ignored
+- Interaction flows do not expire automatically and wait until explicit completion (`answer`, `cancel`, `/stop`, or reset/cleanup)
 
 > `/opencode_start` and `/opencode_stop` are intended as emergency commands — for example, if you need to restart a stuck server while away from your computer. Under normal usage, start `opencode serve` yourself before launching the bot.
 
@@ -114,20 +122,23 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                   | Description                                  | Required | Default                 |
-| -------------------------- | -------------------------------------------- | :------: | ----------------------- |
-| `TELEGRAM_BOT_TOKEN`       | Bot token from @BotFather                    |   Yes    | —                       |
-| `TELEGRAM_ALLOWED_USER_ID` | Your numeric Telegram user ID                |   Yes    | —                       |
-| `TELEGRAM_PROXY_URL`       | Proxy URL for Telegram API (SOCKS5/HTTP)     |    No    | —                       |
-| `OPENCODE_API_URL`         | OpenCode server URL                          |    No    | `http://localhost:4096` |
-| `OPENCODE_SERVER_USERNAME` | Server auth username                         |    No    | `opencode`              |
-| `OPENCODE_SERVER_PASSWORD` | Server auth password                         |    No    | —                       |
-| `OPENCODE_MODEL_PROVIDER`  | Default model provider                       |   Yes    | `opencode`              |
-| `OPENCODE_MODEL_ID`        | Default model ID                             |   Yes    | `big-pickle`            |
-| `BOT_LOCALE`               | Bot UI language (`en` or `ru`)               |    No    | `en`                    |
-| `SESSIONS_LIST_LIMIT`      | Max sessions shown in `/sessions`            |    No    | `10`                    |
-| `CODE_FILE_MAX_SIZE_KB`    | Max file size (KB) to send as document       |    No    | `100`                   |
-| `LOG_LEVEL`                | Log level (`debug`, `info`, `warn`, `error`) |    No    | `info`                  |
+| Variable                        | Description                                                                                                  | Required | Default                 |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ----------------------- |
+| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                       |
+| `TELEGRAM_ALLOWED_USER_ID`      | Your numeric Telegram user ID                                                                                |   Yes    | —                       |
+| `TELEGRAM_PROXY_URL`            | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                     |    No    | —                       |
+| `OPENCODE_API_URL`              | OpenCode server URL                                                                                          |    No    | `http://localhost:4096` |
+| `OPENCODE_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`              |
+| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                       |
+| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`              |
+| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`            |
+| `BOT_LOCALE`                    | Bot UI language (`en` or `ru`)                                                                               |    No    | `en`                    |
+| `SESSIONS_LIST_LIMIT`           | Max sessions shown in `/sessions`                                                                            |    No    | `10`                    |
+| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                     |
+| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                 |
+| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                 |
+| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                   |
+| `LOG_LEVEL`                     | Log level (`debug`, `info`, `warn`, `error`)                                                                 |    No    | `info`                  |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 

package/dist/bot/commands/definitions.js

@@ -16,7 +16,10 @@ const COMMAND_DEFINITIONS = [
     { command: "opencode_stop", descriptionKey: "cmd.description.opencode_stop" },
     { command: "help", descriptionKey: "cmd.description.help" },
 ];
-export const BOT_COMMANDS = COMMAND_DEFINITIONS.map(({ command, descriptionKey }) => ({
-    command,
-    description: t(descriptionKey),
-}));
+export function getLocalizedBotCommands() {
+    return COMMAND_DEFINITIONS.map(({ command, descriptionKey }) => ({
+        command,
+        description: t(descriptionKey),
+    }));
+}
+export const BOT_COMMANDS = getLocalizedBotCommands();

package/dist/bot/commands/help.js

@@ -1,4 +1,10 @@
 import { t } from "../../i18n/index.js";
+import { getLocalizedBotCommands } from "./definitions.js";
+function formatHelpText() {
+    const commands = getLocalizedBotCommands();
+    const lines = commands.map((item) => `/${item.command} - ${item.description}`);
+    return `📖 ${t("cmd.description.help")}\n\n${lines.join("\n")}`;
+}
 export async function helpCommand(ctx) {
-    await ctx.reply(t("help.text"), { parse_mode: "Markdown" });
+    await ctx.reply(formatHelpText());
 }

package/dist/bot/commands/new.js

@@ -2,6 +2,8 @@ import { opencodeClient } from "../../opencode/client.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { getStoredAgent } from "../../agent/manager.js";
@@ -31,6 +33,8 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
+        clearAllInteractionState("session_created");
         await ingestSessionInfoForCache(session);
         // Initialize pinned message manager and create pinned message
         if (!pinnedMessageManager.isInitialized()) {

package/dist/bot/commands/projects.js

@@ -9,7 +9,9 @@ import { keyboardManager } from "../../keyboard/manager.js";
 import { getStoredAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
+import { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
@@ -42,15 +44,16 @@ export async function projectsCommand(ctx) {
             const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
             keyboard.text(labelWithCheck, `project:${project.id}`).row();
         });
-        if (currentProject) {
-            const projectName = currentProject.name || currentProject.worktree;
-            await ctx.reply(t("projects.select_with_current", { project: projectName }), {
-                reply_markup: keyboard,
-            });
-        }
-        else {
-            await ctx.reply(t("projects.select"), { reply_markup: keyboard });
-        }
+        const text = currentProject
+            ? t("projects.select_with_current", {
+                project: currentProject.name || currentProject.worktree,
+            })
+            : t("projects.select");
+        await replyWithInlineMenu(ctx, {
+            menuKind: "project",
+            text,
+            keyboard,
+        });
     }
     catch (error) {
         logger.error("[Bot] Error fetching projects:", error);
@@ -63,6 +66,10 @@ export async function handleProjectSelect(ctx) {
         return false;
     }
     const projectId = callbackQuery.data.replace("project:", "");
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
+    if (!isActiveMenu) {
+        return true;
+    }
     try {
         const projects = await getProjects();
         const selectedProject = projects.find((p) => p.id === projectId);
@@ -73,6 +80,7 @@ export async function handleProjectSelect(ctx) {
         setCurrentProject(selectedProject);
         clearSession();
         summaryAggregator.clear();
+        clearAllInteractionState("project_switched");
         // Clear pinned message when switching projects
         try {
             await pinnedMessageManager.clear();
@@ -103,6 +111,7 @@ export async function handleProjectSelect(ctx) {
         await ctx.deleteMessage();
     }
     catch (error) {
+        clearAllInteractionState("project_select_error");
         logger.error("[Bot] Error selecting project:", error);
         await ctx.answerCallbackQuery();
         await ctx.reply(t("projects.select_error"));

package/dist/bot/commands/rename.js

@@ -2,9 +2,24 @@ import { InlineKeyboard } from "grammy";
 import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentSession, setCurrentSession } from "../../session/manager.js";
 import { renameManager } from "../../rename/manager.js";
+import { interactionManager } from "../../interaction/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function clearRenameInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "rename") {
+        interactionManager.clear(reason);
+    }
+}
 export async function renameCommand(ctx) {
     try {
         const currentSession = getCurrentSession();
@@ -18,6 +33,14 @@ export async function renameCommand(ctx) {
         });
         renameManager.startWaiting(currentSession.id, currentSession.directory, currentSession.title);
         renameManager.setMessageId(message.message_id);
+        interactionManager.start({
+            kind: "rename",
+            expectedInput: "text",
+            metadata: {
+                sessionId: currentSession.id,
+                messageId: message.message_id,
+            },
+        });
         logger.info(`[RenameCommand] Waiting for new title for session: ${currentSession.id}`);
     }
     catch (error) {
@@ -31,9 +54,26 @@ export async function handleRenameCancel(ctx) {
         return false;
     }
     logger.debug("[RenameHandler] Cancel callback received");
+    if (!renameManager.isWaitingForName()) {
+        clearRenameInteraction("rename_cancel_inactive");
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const interactionState = interactionManager.getSnapshot();
+    if (interactionState?.kind !== "rename") {
+        renameManager.clear();
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!renameManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
     renameManager.clear();
+    clearRenameInteraction("rename_cancelled");
     await ctx.answerCallbackQuery();
-    await ctx.editMessageText(t("rename.cancelled"));
+    await ctx.editMessageText(t("rename.cancelled")).catch(() => { });
     return true;
 }
 export async function handleRenameTextAnswer(ctx) {
@@ -47,9 +87,16 @@ export async function handleRenameTextAnswer(ctx) {
     if (text.startsWith("/")) {
         return false;
     }
+    const interactionState = interactionManager.getSnapshot();
+    if (interactionState?.kind !== "rename") {
+        renameManager.clear();
+        await ctx.reply(t("rename.inactive"));
+        return true;
+    }
     const sessionInfo = renameManager.getSessionInfo();
     if (!sessionInfo) {
         renameManager.clear();
+        clearRenameInteraction("rename_missing_session_info");
         return false;
     }
     const newTitle = text.trim();
@@ -87,5 +134,6 @@ export async function handleRenameTextAnswer(ctx) {
         await ctx.reply(t("rename.error"));
     }
     renameManager.clear();
+    clearRenameInteraction("rename_completed");
     return true;
 }

package/dist/bot/commands/sessions.js

@@ -2,8 +2,11 @@ import { InlineKeyboard } from "grammy";
 import { opencodeClient } from "../../opencode/client.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
+import { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { config } from "../../config.js";
@@ -39,8 +42,10 @@ export async function sessionsCommand(ctx) {
             const label = `${index + 1}. ${session.title} (${date})`;
             keyboard.text(label, `session:${session.id}`).row();
         });
-        await ctx.reply(t("sessions.select"), {
-            reply_markup: keyboard,
+        await replyWithInlineMenu(ctx, {
+            menuKind: "session",
+            text: t("sessions.select"),
+            keyboard,
         });
     }
     catch (error) {
@@ -54,9 +59,14 @@ export async function handleSessionSelect(ctx) {
         return false;
     }
     const sessionId = callbackQuery.data.replace("session:", "");
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "session");
+    if (!isActiveMenu) {
+        return true;
+    }
     try {
         const currentProject = getCurrentProject();
         if (!currentProject) {
+            clearAllInteractionState("session_select_project_missing");
             await ctx.answerCallbackQuery();
             await ctx.reply(t("sessions.select_project_first"));
             return true;
@@ -75,6 +85,8 @@ export async function handleSessionSelect(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
+        clearAllInteractionState("session_switched");
         await ctx.answerCallbackQuery();
         let loadingMessageId = null;
         if (ctx.chat) {
@@ -139,6 +151,7 @@ export async function handleSessionSelect(ctx) {
         await ctx.deleteMessage();
     }
     catch (error) {
+        clearAllInteractionState("session_select_error");
         logger.error("[Sessions] Error selecting session:", error);
         await ctx.answerCallbackQuery();
         await ctx.reply(t("sessions.select_error"));

package/dist/bot/commands/stop.js

@@ -1,8 +1,7 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { stopEventListening } from "../../opencode/events.js";
 import { getCurrentSession } from "../../session/manager.js";
-import { permissionManager } from "../../permission/manager.js";
-import { questionManager } from "../../question/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
@@ -10,8 +9,7 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function stopLocalStreaming() {
     stopEventListening();
     summaryAggregator.clear();
-    questionManager.clear();
-    permissionManager.clear();
+    clearAllInteractionState("stop_command");
 }
 async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
     const startedAt = Date.now();
@@ -43,12 +41,12 @@ async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
 }
 export async function stopCommand(ctx) {
     try {
+        stopLocalStreaming();
         const currentSession = getCurrentSession();
         if (!currentSession) {
             await ctx.reply(t("stop.no_active_session"));
             return;
         }
-        stopLocalStreaming();
         const waitingMessage = await ctx.reply(t("stop.in_progress"));
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 5000);

package/dist/bot/handlers/agent.js

@@ -7,6 +7,7 @@ import { logger } from "../../utils/logger.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
 import { t } from "../../i18n/index.js";
 /**
  * Handle agent selection callback
@@ -18,6 +19,10 @@ export async function handleAgentSelect(ctx) {
     if (!callbackQuery?.data || !callbackQuery.data.startsWith("agent:")) {
         return false;
     }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "agent");
+    if (!isActiveMenu) {
+        return true;
+    }
     logger.debug(`[AgentHandler] Received callback: ${callbackQuery.data}`);
     try {
         if (ctx.chat) {
@@ -45,6 +50,7 @@ export async function handleAgentSelect(ctx) {
         const variantName = state?.variantName ?? formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(agentName, currentModel, contextInfo ?? undefined, variantName);
         const displayName = getAgentDisplayName(agentName);
+        clearActiveInlineMenu("agent_selected");
         // Send confirmation message with updated keyboard
         await ctx.answerCallbackQuery({ text: t("agent.changed_callback", { name: displayName }) });
         await ctx.reply(t("agent.changed_message", { name: displayName }), {
@@ -55,6 +61,7 @@ export async function handleAgentSelect(ctx) {
         return true;
     }
     catch (err) {
+        clearActiveInlineMenu("agent_select_error");
         logger.error("[AgentHandler] Error handling agent select:", err);
         await ctx.answerCallbackQuery({ text: t("agent.change_error_callback") }).catch(() => { });
         return false;
@@ -93,5 +100,9 @@ export async function showAgentSelectionMenu(ctx) {
     const text = currentAgent
         ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
         : t("agent.menu.select");
-    await ctx.reply(text, { reply_markup: keyboard });
+    await replyWithInlineMenu(ctx, {
+        menuKind: "agent",
+        text,
+        keyboard,
+    });
 }

package/dist/bot/handlers/context.js

@@ -2,16 +2,16 @@ import { InlineKeyboard } from "grammy";
 import { getCurrentSession } from "../../session/manager.js";
 import { opencodeClient } from "../../opencode/client.js";
 import { getStoredModel } from "../../model/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 /**
  * Build inline keyboard with compact confirmation menu
- * @returns InlineKeyboard with "Yes" and "Cancel" buttons
+ * @returns InlineKeyboard with confirmation button
  */
 export function buildCompactConfirmationMenu() {
     const keyboard = new InlineKeyboard();
-    keyboard.text(t("context.button.confirm"), "compact:confirm").row();
-    keyboard.text(t("context.button.cancel"), "compact:cancel").row();
+    keyboard.text(t("context.button.confirm"), "compact:confirm");
     return keyboard;
 }
 /**
@@ -27,7 +27,11 @@ export async function handleContextButtonPress(ctx) {
         return;
     }
     const keyboard = buildCompactConfirmationMenu();
-    await ctx.reply(t("context.confirm_text", { title: session.title }), { reply_markup: keyboard });
+    await replyWithInlineMenu(ctx, {
+        menuKind: "context",
+        text: t("context.confirm_text", { title: session.title }),
+        keyboard,
+    });
 }
 /**
  * Handle compact confirmation callback
@@ -39,10 +43,15 @@ export async function handleCompactConfirm(ctx) {
     if (!callbackQuery?.data || callbackQuery.data !== "compact:confirm") {
         return false;
     }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "context");
+    if (!isActiveMenu) {
+        return true;
+    }
     logger.debug("[ContextHandler] Compact confirmed");
     try {
         const session = getCurrentSession();
         if (!session) {
+            clearActiveInlineMenu("context_session_missing");
             await ctx.answerCallbackQuery({ text: t("context.callback_session_not_found") });
             await ctx.reply(t("context.no_active_session"));
             await ctx.deleteMessage().catch(() => { });
@@ -50,6 +59,7 @@ export async function handleCompactConfirm(ctx) {
         }
         // Answer callback query and delete menu immediately
         await ctx.answerCallbackQuery({ text: t("context.callback_compacting") });
+        clearActiveInlineMenu("context_compact_confirmed");
         await ctx.deleteMessage().catch(() => { });
         // Send progress message
         const progressMessage = await ctx.reply(t("context.progress"));
@@ -80,6 +90,7 @@ export async function handleCompactConfirm(ctx) {
         return true;
     }
     catch (err) {
+        clearActiveInlineMenu("context_compact_error");
         logger.error("[ContextHandler] Compact exception:", err);
         await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
         await ctx.reply(t("context.error"));
@@ -87,24 +98,3 @@ export async function handleCompactConfirm(ctx) {
         return false;
     }
 }
-/**
- * Handle compact cancel callback
- * @param ctx grammY context
- */
-export async function handleCompactCancel(ctx) {
-    const callbackQuery = ctx.callbackQuery;
-    if (!callbackQuery?.data || callbackQuery.data !== "compact:cancel") {
-        return false;
-    }
-    logger.debug("[ContextHandler] Compact cancelled");
-    try {
-        await ctx.answerCallbackQuery({ text: t("context.callback_cancelled") });
-        // Delete the inline menu message
-        await ctx.deleteMessage().catch(() => { });
-        return true;
-    }
-    catch (err) {
-        logger.error("[ContextHandler] Cancel error:", err);
-        return false;
-    }
-}

package/dist/bot/handlers/inline-menu.js

@@ -0,0 +1,119 @@
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
+const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
+const INLINE_MENU_KINDS = ["project", "session", "model", "agent", "variant", "context"];
+function isInlineMenuKind(value) {
+    return INLINE_MENU_KINDS.includes(value);
+}
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function getActiveInlineMenuMetadata(state) {
+    if (!state || state.kind !== "inline") {
+        return null;
+    }
+    const menuKind = state.metadata.menuKind;
+    const messageId = state.metadata.messageId;
+    if (typeof menuKind !== "string" || !isInlineMenuKind(menuKind)) {
+        return null;
+    }
+    if (typeof messageId !== "number") {
+        return null;
+    }
+    return {
+        menuKind,
+        messageId,
+    };
+}
+function getInlineCancelCallbackData(menuKind) {
+    return `${INLINE_MENU_CANCEL_PREFIX}${menuKind}`;
+}
+export function appendInlineMenuCancelButton(keyboard, menuKind) {
+    while (keyboard.inline_keyboard.length > 0 &&
+        keyboard.inline_keyboard[keyboard.inline_keyboard.length - 1].length === 0) {
+        keyboard.inline_keyboard.pop();
+    }
+    if (keyboard.inline_keyboard.length > 0) {
+        keyboard.row();
+    }
+    keyboard.text(t("inline.button.cancel"), getInlineCancelCallbackData(menuKind));
+    return keyboard;
+}
+export async function replyWithInlineMenu(ctx, options) {
+    const keyboard = appendInlineMenuCancelButton(options.keyboard, options.menuKind);
+    const replyOptions = {
+        reply_markup: keyboard,
+    };
+    if (options.parseMode) {
+        replyOptions.parse_mode = options.parseMode;
+    }
+    const message = await ctx.reply(options.text, replyOptions);
+    interactionManager.start({
+        kind: "inline",
+        expectedInput: "callback",
+        metadata: {
+            menuKind: options.menuKind,
+            messageId: message.message_id,
+        },
+    });
+    logger.debug(`[InlineMenu] Opened menu: kind=${options.menuKind}, messageId=${message.message_id}`);
+    return message.message_id;
+}
+export async function ensureActiveInlineMenu(ctx, menuKind) {
+    const activeMetadata = getActiveInlineMenuMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    const isActive = !!activeMetadata &&
+        callbackMessageId !== null &&
+        activeMetadata.menuKind === menuKind &&
+        activeMetadata.messageId === callbackMessageId;
+    if (isActive) {
+        return true;
+    }
+    logger.debug(`[InlineMenu] Stale callback ignored: expectedKind=${menuKind}, activeKind=${activeMetadata?.menuKind || "none"}, callbackMessageId=${callbackMessageId || "none"}, activeMessageId=${activeMetadata?.messageId || "none"}`);
+    await ctx
+        .answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true })
+        .catch(() => { });
+    return false;
+}
+export function clearActiveInlineMenu(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "inline") {
+        interactionManager.clear(reason);
+    }
+}
+export async function handleInlineMenuCancel(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data) {
+        return false;
+    }
+    let menuKind = null;
+    if (data === LEGACY_CONTEXT_CANCEL_CALLBACK) {
+        menuKind = "context";
+    }
+    else if (data.startsWith(INLINE_MENU_CANCEL_PREFIX)) {
+        const rawKind = data.slice(INLINE_MENU_CANCEL_PREFIX.length);
+        if (!isInlineMenuKind(rawKind)) {
+            return false;
+        }
+        menuKind = rawKind;
+    }
+    else {
+        return false;
+    }
+    const isActive = await ensureActiveInlineMenu(ctx, menuKind);
+    if (!isActive) {
+        return true;
+    }
+    clearActiveInlineMenu(`inline_menu_cancel:${menuKind}`);
+    await ctx.answerCallbackQuery({ text: t("inline.cancelled_callback") }).catch(() => { });
+    await ctx.deleteMessage().catch(() => { });
+    logger.debug(`[InlineMenu] Menu cancelled: kind=${menuKind}`);
+    return true;
+}