@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/{scheduled-task/runtime.js → app/services/scheduled-task-runtime-service.js}

@@ -1,40 +1,16 @@
-import { config } from "../config.js";
-import { escapePlainTextForTelegramMarkdownV2, formatSummaryWithMode, } from "../summary/formatter.js";
-import { t } from "../i18n/index.js";
-import { logger } from "../utils/logger.js";
-import { safeBackgroundTask } from "../utils/safe-background-task.js";
-import { sendBotText } from "../bot/utils/telegram-text.js";
-import { formatAssistantRunFooter } from "../bot/utils/assistant-run-footer.js";
-import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./executor.js";
-import { foregroundSessionState } from "./foreground-state.js";
-import { cleanupScheduledTaskSessionIgnores } from "./session-ignore.js";
-import { computeNextRunAt, isTaskDue } from "./next-run.js";
-import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
+import { config } from "../../config.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { formatAssistantRunFooter } from "../formatters/assistant-run-footer-formatter.js";
+import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./scheduled-task-executor-service.js";
+import { foregroundSessionState } from "../managers/foreground-session-state-manager.js";
+import { cleanupScheduledTaskSessionIgnores } from "./scheduled-task-session-ignore-service.js";
+import { computeNextRunAt, isTaskDue } from "./scheduled-task-next-run-service.js";
+import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "../stores/scheduled-task-store.js";
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
-const TELEGRAM_MESSAGE_LIMIT = 4096;
 const TASK_DESCRIPTION_PREVIEW_LENGTH = 64;
 const RESTART_INTERRUPTED_ERROR = "Interrupted by bot restart during scheduled task execution.";
-function getScheduledTaskDeliveryFormat() {
-    return config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw";
-}
-function buildScheduledTaskSuccessMessageParts(delivery) {
-    if (!delivery.resultText) {
-        return [delivery.notificationText];
-    }
-    if (config.bot.messageFormatMode !== "markdown") {
-        return formatSummaryWithMode(`${delivery.notificationText}\n\n${delivery.resultText}`, config.bot.messageFormatMode);
-    }
-    const header = escapePlainTextForTelegramMarkdownV2(delivery.notificationText);
-    const resultParts = formatSummaryWithMode(delivery.resultText, config.bot.messageFormatMode);
-    if (resultParts.length === 0) {
-        return [header];
-    }
-    const firstPart = `${header}\n\n${resultParts[0]}`;
-    if (firstPart.length <= TELEGRAM_MESSAGE_LIMIT) {
-        return [firstPart, ...resultParts.slice(1)];
-    }
-    return [header, ...resultParts];
-}
 function normalizeTaskPrompt(prompt) {
     const normalized = prompt.replace(/\s+/g, " ").trim();
     if (normalized.length <= TASK_DESCRIPTION_PREVIEW_LENGTH) {
@@ -85,14 +61,16 @@ function buildErrorDelivery(task, runAt, errorMessage) {
 export class ScheduledTaskRuntime {
     botApi = null;
     chatId = null;
+    deliverySender = null;
     initialized = false;
     timersByTaskId = new Map();
     runningTaskIds = new Set();
     deliveryQueue = [];
     flushInProgress = false;
-    async initialize(bot) {
+    async initialize(bot, deliverySender) {
         this.botApi = bot.api;
         this.chatId = config.telegram.allowedUserId;
+        this.deliverySender = deliverySender ?? null;
         if (this.initialized) {
             return;
         }
@@ -153,6 +131,7 @@ export class ScheduledTaskRuntime {
         }
         this.botApi = null;
         this.chatId = null;
+        this.deliverySender = null;
         this.initialized = false;
         this.timersByTaskId.clear();
         this.runningTaskIds.clear();
@@ -370,28 +349,10 @@ export class ScheduledTaskRuntime {
             return false;
         }
         try {
-            const messageParts = delivery.status === "success"
-                ? buildScheduledTaskSuccessMessageParts(delivery)
-                : [delivery.notificationText];
-            const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
-            const suppressResultNotification = delivery.status === "success" && Boolean(delivery.footerText);
-            for (const part of messageParts) {
-                await sendBotText({
-                    api: this.botApi,
-                    chatId: this.chatId,
-                    text: part,
-                    format,
-                    ...(suppressResultNotification ? { options: { disable_notification: true } } : {}),
-                });
-            }
-            if (delivery.status === "success" && delivery.footerText) {
-                await sendBotText({
-                    api: this.botApi,
-                    chatId: this.chatId,
-                    text: delivery.footerText,
-                    format: "raw",
-                });
+            if (this.deliverySender) {
+                return await this.deliverySender.send(delivery);
             }
+            await this.botApi.sendMessage(this.chatId, delivery.notificationText);
             return true;
         }
         catch (error) {

package/dist/{scheduled-task/schedule-parser.js → app/services/scheduled-task-schedule-parser-service.js}

@@ -1,6 +1,6 @@
-import { opencodeClient } from "../opencode/client.js";
-import { logger } from "../utils/logger.js";
-import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./scheduled-task-session-ignore-service.js";
 const SCHEDULE_PARSE_SESSION_TITLE = "Scheduled task schedule parser";
 function getLocalTimezone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";

package/dist/{scheduled-task/session-ignore.js → app/services/scheduled-task-session-ignore-service.js}

@@ -1,4 +1,4 @@
-import { getScheduledTaskSessionIgnores, setScheduledTaskSessionIgnores, } from "../settings/manager.js";
+import { getScheduledTaskSessionIgnores, setScheduledTaskSessionIgnores, } from "../stores/settings-store.js";
 const SCHEDULED_TASK_SESSION_IGNORE_TTL_MS = 24 * 60 * 60 * 1000;
 let mutationQueue = Promise.resolve();
 function isFreshIgnore(ignore, nowMs) {

package/dist/{session/cache-manager.js → app/services/session-cache-service.js}

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 import Database from "better-sqlite3";
-import { opencodeClient } from "../opencode/client.js";
-import { getSessionDirectoryCache, setSessionDirectoryCache } from "../settings/manager.js";
-import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getSessionDirectoryCache, setSessionDirectoryCache } from "../stores/settings-store.js";
+import { logger } from "../../utils/logger.js";
 const CACHE_VERSION = 1;
 const INITIAL_WARMUP_LIMIT = 1000;
 const INCREMENTAL_SYNC_LIMIT = 1000;

package/dist/{session/manager.js → app/services/session-service.js}

@@ -1,4 +1,4 @@
-import { getCurrentSession as getSettingsSession, setCurrentSession as setSettingsSession, clearSession as clearSettingsSession, } from "../settings/manager.js";
+import { getCurrentSession as getSettingsSession, setCurrentSession as setSettingsSession, clearSession as clearSettingsSession, } from "../stores/settings-store.js";
 export function setCurrentSession(sessionInfo) {
     setSettingsSession(sessionInfo);
 }

package/dist/app/services/skills-catalog-service.js

@@ -0,0 +1,21 @@
+import { opencodeClient } from "../../opencode/client.js";
+function normalizeDirectoryForCommandApi(directory) {
+    return directory.replace(/\\/g, "/");
+}
+export async function loadSkillsCatalog(projectDirectory) {
+    const { data, error } = await opencodeClient.command.list({
+        directory: normalizeDirectoryForCommandApi(projectDirectory),
+    });
+    if (error || !data) {
+        throw error || new Error("No skill data received");
+    }
+    return data
+        .filter((skill) => {
+        const source = skill.source;
+        return typeof skill.name === "string" && skill.name.trim().length > 0 && source === "skill";
+    })
+        .map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+    }));
+}

package/dist/{stt/client.js → app/services/stt-service.js}

@@ -1,5 +1,5 @@
-import { config } from "../config.js";
-import { logger } from "../utils/logger.js";
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
 const STT_REQUEST_TIMEOUT_MS = 60_000;
 /**
  * Returns true if STT is configured (API URL and API key are set).

package/dist/{tts/client.js → app/services/tts-service.js}

@@ -1,7 +1,8 @@
-import { config } from "../config.js";
-import { logger } from "../utils/logger.js";
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
 import textToSpeech from "@google-cloud/text-to-speech";
 const TTS_REQUEST_TIMEOUT_MS = 60_000;
+const MAX_TTS_INPUT_CHARS = 4_000;
 export function isTtsConfigured() {
     if (config.tts.provider === "google") {
         return Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS);
@@ -104,11 +105,51 @@ async function synthesizeWithOpenAi(text) {
         clearTimeout(timeout);
     }
 }
+async function synthesizeWithElevenLabs(text) {
+    const apiUrl = config.tts.apiUrl.replace(/\/+$/, "");
+    const voiceId = config.tts.voice || "21m00Tcm4TlvDq8ikWAM";
+    const url = `${apiUrl}/text-to-speech/${encodeURIComponent(voiceId)}`;
+    logger.debug(`[TTS] ElevenLabs: url=${url}, model=${config.tts.model}, voice=${voiceId}, chars=${text.length}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TTS_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "xi-api-key": config.tts.apiKey,
+                "Content-Type": "application/json",
+                Accept: "audio/mpeg",
+            },
+            body: JSON.stringify({
+                text,
+                model_id: config.tts.model || "eleven_flash_v2_5",
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            throw new Error(`TTS API returned HTTP ${response.status}: ${errorBody || response.statusText}`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.length === 0) {
+            throw new Error("ElevenLabs TTS API returned an empty audio response");
+        }
+        logger.debug(`[TTS] Generated ElevenLabs speech audio: ${buffer.length} bytes`);
+        return { buffer, filename: "assistant-reply.mp3", mimeType: "audio/mpeg" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 // --- Public API ---
 function getNotConfiguredMessage() {
-    return config.tts.provider === "google"
-        ? "TTS is not configured: set GOOGLE_APPLICATION_CREDENTIALS for Google Cloud TTS"
-        : "TTS is not configured: set TTS_API_URL and TTS_API_KEY";
+    if (config.tts.provider === "google") {
+        return "TTS is not configured: set GOOGLE_APPLICATION_CREDENTIALS for Google Cloud TTS";
+    }
+    if (config.tts.provider === "elevenlabs") {
+        return "TTS is not configured: set TTS_API_URL and TTS_API_KEY for ElevenLabs";
+    }
+    return "TTS is not configured: set TTS_API_URL and TTS_API_KEY";
 }
 export async function synthesizeSpeech(text) {
     if (!isTtsConfigured()) {
@@ -123,6 +164,9 @@ export async function synthesizeSpeech(text) {
         if (config.tts.provider === "google") {
             return await synthesizeWithGoogle(input);
         }
+        if (config.tts.provider === "elevenlabs") {
+            return await synthesizeWithElevenLabs(input);
+        }
         return await synthesizeWithOpenAi(input);
     }
     catch (err) {
@@ -132,3 +176,22 @@ export async function synthesizeSpeech(text) {
         throw err;
     }
 }
+export async function prepareTtsResponseForSession({ sessionId, text, consumeResponseMode, isTtsConfigured: isTtsConfiguredImpl = isTtsConfigured, synthesizeSpeech: synthesizeSpeechImpl = synthesizeSpeech, }) {
+    const responseMode = consumeResponseMode(sessionId);
+    if (responseMode !== "text_and_tts") {
+        return { shouldSend: false };
+    }
+    const normalizedText = text.trim();
+    if (!normalizedText) {
+        return { shouldSend: false };
+    }
+    if (!isTtsConfiguredImpl()) {
+        logger.info(`[TTS] Skipping audio reply for session ${sessionId}: TTS is not configured`);
+        return { shouldSend: false };
+    }
+    if (normalizedText.length > MAX_TTS_INPUT_CHARS) {
+        logger.warn(`[TTS] Skipping audio reply for session ${sessionId}: text length ${normalizedText.length} exceeds limit ${MAX_TTS_INPUT_CHARS}`);
+        return { shouldSend: false };
+    }
+    return { shouldSend: true, speech: await synthesizeSpeechImpl(normalizedText) };
+}

package/dist/{variant/manager.js → app/services/variant-selection-service.js}

@@ -1,9 +1,9 @@
 /**
  * Variant Manager - manages model variants (reasoning modes)
  */
-import { opencodeClient } from "../opencode/client.js";
-import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
-import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentModel, setCurrentModel } from "../stores/settings-store.js";
+import { logger } from "../../utils/logger.js";
 /**
  * Get available variants for a model from OpenCode API
  * @param providerID Provider ID

package/dist/{scheduled-task/store.js → app/stores/scheduled-task-store.js}

@@ -1,6 +1,6 @@
-import { getScheduledTasks, setScheduledTasks } from "../settings/manager.js";
-import { logger } from "../utils/logger.js";
-import { cloneScheduledTask } from "./types.js";
+import { getScheduledTasks, setScheduledTasks } from "./settings-store.js";
+import { logger } from "../../utils/logger.js";
+import { cloneScheduledTask } from "../types/scheduled-task.js";
 let scheduledTaskMutationQueue = Promise.resolve();
 async function mutateScheduledTasks(mutator) {
     const runMutation = async () => {

package/dist/{settings/manager.js → app/stores/settings-store.js}

@@ -1,7 +1,7 @@
-import { cloneScheduledTask } from "../scheduled-task/types.js";
 import path from "node:path";
-import { getRuntimePaths } from "../runtime/paths.js";
-import { logger } from "../utils/logger.js";
+import { cloneScheduledTask } from "../types/scheduled-task.js";
+import { getRuntimePaths } from "../../runtime/paths.js";
+import { logger } from "../../utils/logger.js";
 function cloneScheduledTasks(tasks) {
     return tasks?.map((task) => cloneScheduledTask(task));
 }

package/dist/app/types/worktree.js

@@ -0,0 +1 @@
+export {};

package/dist/bot/{handlers/agent.js → callbacks/agent-selection-callback-handler.js}

@@ -1,14 +1,13 @@
-import { InlineKeyboard } from "grammy";
-import { selectAgent, getAvailableAgents, fetchCurrentAgent } from "../../agent/manager.js";
-import { getAgentDisplayName } from "../../agent/types.js";
-import { getStoredModel } from "../../model/manager.js";
-import { formatVariantForButton } from "../../variant/manager.js";
+import { selectAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
+import { getAgentDisplayName } from "../../app/types/agent.js";
 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";
+import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu } from "../menus/inline-menu.js";
 /**
  * Handle agent selection callback
  * @param ctx grammY context
@@ -67,51 +66,3 @@ export async function handleAgentSelect(ctx) {
         return false;
     }
 }
-/**
- * Build inline keyboard with available agents
- * @param currentAgent Current agent name for highlighting
- * @returns InlineKeyboard with agent selection buttons
- */
-export async function buildAgentSelectionMenu(currentAgent) {
-    const keyboard = new InlineKeyboard();
-    const agents = await getAvailableAgents();
-    if (agents.length === 0) {
-        logger.warn("[AgentHandler] No available agents found");
-        return keyboard;
-    }
-    // Add button for each agent
-    agents.forEach((agent) => {
-        const isActive = agent.name === currentAgent;
-        const label = isActive
-            ? `✅ ${getAgentDisplayName(agent.name)}`
-            : getAgentDisplayName(agent.name);
-        keyboard.text(label, `agent:${agent.name}`).row();
-    });
-    return keyboard;
-}
-/**
- * Show agent selection menu
- * @param ctx grammY context
- */
-export async function showAgentSelectionMenu(ctx) {
-    try {
-        const currentAgent = await fetchCurrentAgent();
-        const keyboard = await buildAgentSelectionMenu(currentAgent);
-        if (keyboard.inline_keyboard.length === 0) {
-            await ctx.reply(t("agent.menu.empty"));
-            return;
-        }
-        const text = currentAgent
-            ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
-            : t("agent.menu.select");
-        await replyWithInlineMenu(ctx, {
-            menuKind: "agent",
-            text,
-            keyboard,
-        });
-    }
-    catch (err) {
-        logger.error("[AgentHandler] Error showing agent menu:", err);
-        await ctx.reply(t("agent.menu.error"));
-    }
-}

package/dist/bot/callbacks/callback-router.js

@@ -0,0 +1,110 @@
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { handleAgentSelect } from "./agent-selection-callback-handler.js";
+import { handleCommandsCallback } from "./command-catalog-callback-handler.js";
+import { handleCompactConfirm } from "./context-control-callback-handler.js";
+import { handleLsCallback, handleOpenCallback } from "./file-browser-callback-handler.js";
+import { handleInlineMenuCancel } from "./inline-menu-cancel-callback-handler.js";
+import { handleMcpsCallback } from "./mcp-catalog-callback-handler.js";
+import { handleMessagesCallback } from "./message-history-callback-handler.js";
+import { handleModelSearchCallback, handleModelSearchResults, handleModelSelect, } from "./model-selection-callback-handler.js";
+import { handlePermissionCallback } from "./permission-callback-handler.js";
+import { handleProjectSelect } from "./project-callback-handler.js";
+import { handleQuestionCallback } from "./question-callback-handler.js";
+import { handleRenameCancel } from "./rename-callback-handler.js";
+import { handleBackgroundSessionOpen, handleSessionSelect, } from "./session-callback-handler.js";
+import { handleSkillsCallback } from "./skills-catalog-callback-handler.js";
+import { handleTaskCallback, handleTaskListCallback, } from "./scheduled-task-callback-handler.js";
+import { handleVariantSelect } from "./variant-selection-callback-handler.js";
+import { handleWorktreeCallback } from "./worktree-callback-handler.js";
+import { clearLsPathIndex, clearOpenPathIndex } from "../menus/file-browser-menu.js";
+export function registerCallbackRouter(bot, deps) {
+    bot.on("callback_query:data", async (ctx) => {
+        logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
+        logger.debug(`[Bot] Callback context: from=${ctx.from?.id}, chat=${ctx.chat?.id}`);
+        if (ctx.chat) {
+            deps.setTelegramContext(bot, ctx.chat.id);
+        }
+        try {
+            const handledBackgroundSession = await handleBackgroundSessionOpen(ctx, {
+                bot,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledInlineCancel = await handleInlineMenuCancel(ctx);
+            if (handledInlineCancel) {
+                clearOpenPathIndex();
+                clearLsPathIndex();
+            }
+            const handledSession = await handleSessionSelect(ctx, {
+                bot,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledProject = await handleProjectSelect(ctx, {
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledWorktree = await handleWorktreeCallback(ctx, {
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledOpen = await handleOpenCallback(ctx, {
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledLs = await handleLsCallback(ctx);
+            const handledQuestion = await handleQuestionCallback(ctx);
+            const handledPermission = await handlePermissionCallback(ctx);
+            const handledAgent = await handleAgentSelect(ctx);
+            const handledModelSearch = await handleModelSearchCallback(ctx);
+            const handledModelSearchResults = await handleModelSearchResults(ctx);
+            const handledModel = await handleModelSelect(ctx);
+            const handledVariant = await handleVariantSelect(ctx);
+            const handledCompactConfirm = await handleCompactConfirm(ctx);
+            const handledTask = await handleTaskCallback(ctx);
+            const handledTaskList = await handleTaskListCallback(ctx);
+            const handledRenameCancel = await handleRenameCancel(ctx);
+            const handledCommands = await handleCommandsCallback(ctx, {
+                bot,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledMessages = await handleMessagesCallback(ctx, {
+                bot,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledSkills = await handleSkillsCallback(ctx, {
+                bot,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
+            const handledMcps = await handleMcpsCallback(ctx);
+            logger.debug(`[Bot] Callback handled: backgroundSession=${handledBackgroundSession}, inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, ls=${handledLs}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, modelSearch=${handledModelSearch}, modelSearchResults=${handledModelSearchResults}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, messages=${handledMessages}, skills=${handledSkills}, mcps=${handledMcps}`);
+            if (!handledBackgroundSession &&
+                !handledInlineCancel &&
+                !handledSession &&
+                !handledProject &&
+                !handledWorktree &&
+                !handledOpen &&
+                !handledLs &&
+                !handledQuestion &&
+                !handledPermission &&
+                !handledAgent &&
+                !handledModelSearch &&
+                !handledModelSearchResults &&
+                !handledModel &&
+                !handledVariant &&
+                !handledCompactConfirm &&
+                !handledTask &&
+                !handledTaskList &&
+                !handledRenameCancel &&
+                !handledCommands &&
+                !handledMessages &&
+                !handledSkills &&
+                !handledMcps) {
+                logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
+                await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
+            }
+        }
+        catch (err) {
+            logger.error("[Bot] Error handling callback:", err);
+            clearAllInteractionState("callback_handler_error");
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        }
+    });
+}