zardbot-telegram 1.0.0

package/dist/bot/handlers/question.js

@@ -0,0 +1,390 @@
+import { InlineKeyboard } from "grammy";
+import { questionManager } from "../../question/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { t } from "../../i18n/index.js";
+const MAX_BUTTON_LENGTH = 60;
+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 clearQuestionInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "question") {
+        interactionManager.clear(reason);
+    }
+}
+function syncQuestionInteractionState(expectedInput, questionIndex, messageId) {
+    const metadata = {
+        questionIndex,
+        inputMode: expectedInput === "mixed" ? "custom" : "options",
+    };
+    const requestID = questionManager.getRequestID();
+    if (requestID) {
+        metadata.requestID = requestID;
+    }
+    if (messageId !== null) {
+        metadata.messageId = messageId;
+    }
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "question") {
+        interactionManager.transition({
+            expectedInput,
+            metadata,
+        });
+        return;
+    }
+    interactionManager.start({
+        kind: "question",
+        expectedInput,
+        metadata,
+    });
+}
+export async function handleQuestionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("question:")) {
+        return false;
+    }
+    logger.debug(`[QuestionHandler] Received callback: ${data}`);
+    if (!questionManager.isActive()) {
+        clearQuestionInteraction("question_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!questionManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    if (Number.isNaN(questionIndex) || questionIndex !== questionManager.getCurrentIndex()) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        switch (action) {
+            case "select":
+                {
+                    const optionIndex = parseInt(parts[3], 10);
+                    if (Number.isNaN(optionIndex)) {
+                        await ctx.answerCallbackQuery({
+                            text: t("question.processing_error_callback"),
+                            show_alert: true,
+                        });
+                        break;
+                    }
+                    await handleSelectOption(ctx, questionIndex, optionIndex);
+                }
+                break;
+            case "submit":
+                await handleSubmitAnswer(ctx, questionIndex);
+                break;
+            case "custom":
+                await handleCustomAnswer(ctx, questionIndex);
+                break;
+            case "cancel":
+                await handleCancelPoll(ctx);
+                break;
+            default:
+                await ctx.answerCallbackQuery({
+                    text: t("question.processing_error_callback"),
+                    show_alert: true,
+                });
+                break;
+        }
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({
+            text: t("question.processing_error_callback"),
+            show_alert: true,
+        });
+    }
+    return true;
+}
+async function handleSelectOption(ctx, questionIndex, optionIndex) {
+    logger.debug(`[QuestionHandler] handleSelectOption: qIndex=${questionIndex}, oIndex=${optionIndex}`);
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        logger.debug("[QuestionHandler] No current question");
+        return;
+    }
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
+    questionManager.selectOption(questionIndex, optionIndex);
+    if (question.multiple) {
+        logger.debug("[QuestionHandler] Multiple choice mode, updating message");
+        await updateQuestionMessage(ctx);
+        await ctx.answerCallbackQuery();
+    }
+    else {
+        logger.debug("[QuestionHandler] Single choice mode, moving to next question");
+        await ctx.answerCallbackQuery();
+        const answer = questionManager.getSelectedAnswer(questionIndex);
+        logger.debug(`[QuestionHandler] Selected answer for question ${questionIndex}: ${answer}`);
+        // Delete the question message before showing the next one
+        await ctx.deleteMessage().catch(() => { });
+        // DO NOT send the answer immediately - move to the next question
+        // All answers will be sent together after the user answers all questions
+        await showNextQuestion(ctx);
+    }
+}
+async function handleSubmitAnswer(ctx, questionIndex) {
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
+    const answer = questionManager.getSelectedAnswer(questionIndex);
+    if (!answer) {
+        await ctx.answerCallbackQuery({
+            text: t("question.select_one_required_callback"),
+            show_alert: true,
+        });
+        return;
+    }
+    logger.debug(`[QuestionHandler] Submit answer for question ${questionIndex}: ${answer}`);
+    await ctx.answerCallbackQuery();
+    // Delete the question message before showing the next one
+    await ctx.deleteMessage().catch(() => { });
+    // DO NOT send the answer immediately - move to the next question
+    // All answers will be sent together after the user answers all questions
+    await showNextQuestion(ctx);
+}
+async function handleCustomAnswer(ctx, questionIndex) {
+    questionManager.startCustomInput(questionIndex);
+    syncQuestionInteractionState("mixed", questionIndex, questionManager.getActiveMessageId());
+    await ctx.answerCallbackQuery({
+        text: t("question.enter_custom_callback"),
+        show_alert: true,
+    });
+}
+async function handleCancelPoll(ctx) {
+    questionManager.cancel();
+    clearQuestionInteraction("question_cancelled");
+    await ctx.editMessageText(t("question.cancelled")).catch(() => { });
+    await ctx.answerCallbackQuery();
+    questionManager.clear();
+}
+async function updateQuestionMessage(ctx) {
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        logger.debug("[QuestionHandler] updateQuestionMessage: no current question");
+        return;
+    }
+    const text = formatQuestionText(question);
+    const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
+    logger.debug("[QuestionHandler] Updating question message");
+    try {
+        await ctx.editMessageText(text, {
+            reply_markup: keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Failed to update message:", err);
+    }
+}
+export async function showCurrentQuestion(bot, chatId) {
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        await showPollSummary(bot, chatId);
+        return;
+    }
+    logger.debug(`[QuestionHandler] Showing question: ${question.header} - ${question.question}`);
+    const text = formatQuestionText(question);
+    const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
+    logger.debug(`[QuestionHandler] Sending message with keyboard, chatId=${chatId}`);
+    try {
+        const message = await bot.sendMessage(chatId, text, {
+            reply_markup: keyboard,
+        });
+        logger.debug(`[QuestionHandler] Message sent, messageId=${message.message_id}`);
+        questionManager.addMessageId(message.message_id);
+        questionManager.setActiveMessageId(message.message_id);
+        syncQuestionInteractionState("callback", questionManager.getCurrentIndex(), questionManager.getActiveMessageId());
+        summaryAggregator.stopTypingIndicator();
+    }
+    catch (err) {
+        questionManager.clear();
+        clearQuestionInteraction("question_message_send_failed");
+        logger.error("[QuestionHandler] Failed to send question message:", err);
+        throw err;
+    }
+}
+export async function handleQuestionTextAnswer(ctx) {
+    const text = ctx.message?.text;
+    if (!text)
+        return;
+    const currentIndex = questionManager.getCurrentIndex();
+    if (!questionManager.isWaitingForCustomInput(currentIndex)) {
+        await ctx.reply(t("question.use_custom_button_first"));
+        return;
+    }
+    if (questionManager.hasCustomAnswer(currentIndex)) {
+        await ctx.reply(t("question.answer_already_received"));
+        return;
+    }
+    logger.debug(`[QuestionHandler] Custom text answer for question ${currentIndex}: ${text}`);
+    questionManager.setCustomAnswer(currentIndex, text);
+    questionManager.clearCustomInput();
+    // Delete the previous question message
+    const activeMessageId = questionManager.getActiveMessageId();
+    if (activeMessageId !== null && ctx.chat) {
+        await ctx.api.deleteMessage(ctx.chat.id, activeMessageId).catch(() => { });
+    }
+    // DO NOT send the answer immediately - move to the next question
+    // All answers will be sent together after the user answers all questions
+    await showNextQuestion(ctx);
+}
+async function showNextQuestion(ctx) {
+    questionManager.nextQuestion();
+    if (!ctx.chat) {
+        return;
+    }
+    if (questionManager.hasNextQuestion()) {
+        await showCurrentQuestion(ctx.api, ctx.chat.id);
+    }
+    else {
+        await showPollSummary(ctx.api, ctx.chat.id);
+    }
+}
+async function showPollSummary(bot, chatId) {
+    const answers = questionManager.getAllAnswers();
+    const totalQuestions = questionManager.getTotalQuestions();
+    logger.info(`[QuestionHandler] Poll completed: ${answers.length}/${totalQuestions} questions answered`);
+    // Send all answers to the OpenCode API
+    await sendAllAnswersToAgent(bot, chatId);
+    if (answers.length === 0) {
+        await bot.sendMessage(chatId, t("question.completed_no_answers"));
+    }
+    else {
+        const summary = formatAnswersSummary(answers);
+        await bot.sendMessage(chatId, summary);
+    }
+    clearQuestionInteraction("question_completed");
+    questionManager.clear();
+    logger.debug("[QuestionHandler] Poll completed and cleared");
+}
+async function sendAllAnswersToAgent(bot, chatId) {
+    const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
+    const requestID = questionManager.getRequestID();
+    const totalQuestions = questionManager.getTotalQuestions();
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!directory) {
+        logger.error("[QuestionHandler] No project for sending answers");
+        await bot.sendMessage(chatId, t("question.no_active_project"));
+        return;
+    }
+    if (!requestID) {
+        logger.error("[QuestionHandler] No requestID for sending answers");
+        await bot.sendMessage(chatId, t("question.no_active_request"));
+        return;
+    }
+    // Collect answers for all questions
+    // Format: Array<Array<string>> - for each question, an array of strings (selected options)
+    const allAnswers = [];
+    for (let i = 0; i < totalQuestions; i++) {
+        const customAnswer = questionManager.getCustomAnswer(i);
+        const selectedAnswer = questionManager.getSelectedAnswer(i);
+        // Priority: custom answer > selected options
+        const answer = customAnswer || selectedAnswer || "";
+        if (answer) {
+            // Split by newlines if multiple options were selected (in multiple choice mode)
+            // Each option is formatted as "* Label: Description"
+            const answerParts = answer.split("\n").filter((part) => part.trim());
+            allAnswers.push(answerParts);
+        }
+        else {
+            // Empty answer for unanswered questions
+            allAnswers.push([]);
+        }
+    }
+    logger.info(`[QuestionHandler] Sending all ${totalQuestions} answers to agent via question.reply: requestID=${requestID}`);
+    logger.debug(`[QuestionHandler] Answers payload:`, JSON.stringify(allAnswers, null, 2));
+    // CRITICAL: Fire-and-forget! Do not wait for question.reply to complete,
+    // otherwise it may block subsequent updates
+    safeBackgroundTask({
+        taskName: "question.reply",
+        task: () => opencodeClient.question.reply({
+            requestID,
+            directory,
+            answers: allAnswers,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[QuestionHandler] Failed to send answers via question.reply:", error);
+                void bot.sendMessage(chatId, t("question.send_answers_error")).catch(() => { });
+                return;
+            }
+            logger.info("[QuestionHandler] All answers sent to agent successfully via question.reply");
+        },
+    });
+}
+function formatQuestionText(question) {
+    const currentIndex = questionManager.getCurrentIndex();
+    const totalQuestions = questionManager.getTotalQuestions();
+    const progressText = totalQuestions > 0 ? `${currentIndex + 1}/${totalQuestions}` : "";
+    const headerTitle = [progressText, question.header].filter(Boolean).join(" ");
+    const header = headerTitle ? `${headerTitle}\n\n` : "";
+    const multiple = question.multiple ? t("question.multi_hint") : "";
+    return `${header}${question.question}${multiple}`;
+}
+function buildQuestionKeyboard(question, selectedOptions) {
+    const keyboard = new InlineKeyboard();
+    const questionIndex = questionManager.getCurrentIndex();
+    logger.debug(`[QuestionHandler] Building keyboard for question ${questionIndex}`);
+    question.options.forEach((option, index) => {
+        const isSelected = selectedOptions.has(index);
+        const icon = isSelected ? "✅ " : "";
+        const buttonText = formatButtonText(option.label, option.description, icon);
+        const callbackData = `question:select:${questionIndex}:${index}`;
+        logger.debug(`[QuestionHandler] Button ${index}: "${buttonText}" -> "${callbackData}"`);
+        keyboard.text(buttonText, callbackData).row();
+    });
+    if (question.multiple) {
+        keyboard.text(t("question.button.submit"), `question:submit:${questionIndex}`).row();
+        logger.debug(`[QuestionHandler] Added submit button`);
+    }
+    keyboard.text(t("question.button.custom"), `question:custom:${questionIndex}`).row();
+    logger.debug(`[QuestionHandler] Added custom answer button`);
+    keyboard.text(t("question.button.cancel"), `question:cancel:${questionIndex}`);
+    logger.debug(`[QuestionHandler] Added cancel button`);
+    logger.debug(`[QuestionHandler] Final keyboard: ${JSON.stringify(keyboard.inline_keyboard)}`);
+    return keyboard;
+}
+function formatButtonText(label, description, icon) {
+    let text = `${icon}${label}`;
+    if (description && icon === "") {
+        text += ` - ${description}`;
+    }
+    if (text.length > MAX_BUTTON_LENGTH) {
+        text = text.substring(0, MAX_BUTTON_LENGTH - 3) + "...";
+    }
+    return text;
+}
+function formatAnswersSummary(answers) {
+    let summary = t("question.summary.title");
+    answers.forEach((item, index) => {
+        summary += t("question.summary.question", {
+            index: index + 1,
+            question: item.question,
+        });
+        summary += t("question.summary.answer", { answer: item.answer });
+    });
+    return summary;
+}

package/dist/bot/handlers/tts.js

@@ -0,0 +1,89 @@
+import { InputFile } from "grammy";
+import { isTtsConfigured, synthesizeSpeech } from "../../tts/client.js";
+import { isTtsEnabled, getCurrentTtsVoice } from "../../settings/manager.js";
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const MAX_TTS_TEXT_LENGTH = 4000; // Telegram voice message limit
+/**
+ * Sends a voice message using TTS if configured and enabled.
+ * Called after the assistant text response is sent.
+ *
+ * @param api - Telegram API instance
+ * @param chatId - Chat ID to send to
+ * @param text - Text to speak
+ * @returns true if TTS was attempted, false if not configured/disabled
+ */
+export async function sendTtsVoiceMessage(api, chatId, text) {
+    // Check if TTS is enabled at all
+    if (!isTtsEnabled()) {
+        return false;
+    }
+    // Check if TTS is configured
+    if (!isTtsConfigured()) {
+        return false;
+    }
+    // Get current voice
+    const voice = getCurrentTtsVoice() || config.tts.voice || "david-attenborough-original";
+    // Truncate text if too long
+    const truncatedText = text.length > MAX_TTS_TEXT_LENGTH
+        ? text.slice(0, MAX_TTS_TEXT_LENGTH) + "..."
+        : text;
+    // Skip empty text
+    if (!truncatedText.trim()) {
+        return false;
+    }
+    logger.debug(`[TTS] Synthesizing speech for ${truncatedText.length} chars with voice ${voice}`);
+    try {
+        const result = await synthesizeSpeech(truncatedText, voice);
+        // Send as voice message using InputFile with Buffer
+        await api.sendVoice(chatId, new InputFile(result.audio, "voice.ogg"), {
+            disable_notification: true,
+        });
+        logger.debug(`[TTS] Voice message sent: ${result.audio.length} bytes`);
+        return true;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        logger.error(`[TTS] Failed to synthesize or send voice: ${errorMessage}`);
+        // Notify user of TTS failure (but don't interrupt flow)
+        try {
+            await api.sendMessage(chatId, t("tts.synthesis_error", { error: errorMessage }), {
+                disable_notification: true,
+            });
+        }
+        catch {
+            // Ignore send errors
+        }
+        return false;
+    }
+}
+/**
+ * Processes text response for TTS.
+ * Strips markdown, code blocks, and other non-speech content.
+ *
+ * @param text - Original text
+ * @returns Cleaned text suitable for TTS
+ */
+export function cleanTextForTts(text) {
+    // Remove code blocks
+    let cleaned = text.replace(/```[\s\S]*?```/g, "");
+    // Remove inline code
+    cleaned = cleaned.replace(/`[^`]+`/g, "");
+    // Remove markdown headers
+    cleaned = cleaned.replace(/^#+\s.*$/gm, "");
+    // Remove markdown links but keep text
+    cleaned = cleaned.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove markdown bold/italic
+    cleaned = cleaned.replace(/[*_]{1,2}([^*_]+)[*_]{1,2}/g, "$1");
+    // Remove markdown lists markers
+    cleaned = cleaned.replace(/^[\s]*[-*+]\s/gm, "");
+    cleaned = cleaned.replace(/^[\s]*\d+\.\s/gm, "");
+    // Remove HTML tags
+    cleaned = cleaned.replace(/<[^>]+>/g, "");
+    // Collapse multiple newlines
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+    // Collapse multiple spaces
+    cleaned = cleaned.replace(/ {2,}/g, " ");
+    return cleaned.trim();
+}

package/dist/bot/handlers/variant.js

@@ -0,0 +1,138 @@
+import { InlineKeyboard } from "grammy";
+import { getAvailableVariants, getCurrentVariant, setCurrentVariant, formatVariantForDisplay, formatVariantForButton, } from "../../variant/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { logger } from "../../utils/logger.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Handle variant selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleVariantSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("variant:")) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "variant");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug(`[VariantHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        if (pinnedMessageManager.getContextLimit() === 0) {
+            await pinnedMessageManager.refreshContextLimit();
+        }
+        // Parse callback data: "variant:variantId"
+        const variantId = callbackQuery.data.replace("variant:", "");
+        // Get current model
+        const currentModel = getStoredModel();
+        if (!currentModel.providerID || !currentModel.modelID) {
+            logger.error("[VariantHandler] No model selected");
+            await ctx.answerCallbackQuery({ text: t("variant.model_not_selected_callback") });
+            return false;
+        }
+        // Set variant
+        setCurrentVariant(variantId);
+        // Re-read model after variant update
+        const updatedModel = getStoredModel();
+        // Update keyboard manager state
+        keyboardManager.updateModel(updatedModel);
+        keyboardManager.updateVariant(variantId);
+        // Build keyboard with correct context info
+        const currentAgent = getStoredAgent();
+        const contextInfo = pinnedMessageManager.getContextInfo() ??
+            (pinnedMessageManager.getContextLimit() > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+                : null);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const variantName = formatVariantForButton(variantId);
+        const keyboard = createMainKeyboard(currentAgent, updatedModel, contextInfo ?? undefined, variantName);
+        // Send confirmation message with updated keyboard
+        const displayName = formatVariantForDisplay(variantId);
+        clearActiveInlineMenu("variant_selected");
+        await ctx.answerCallbackQuery({ text: t("variant.changed_callback", { name: displayName }) });
+        await ctx.reply(t("variant.changed_message", { name: displayName }), {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("variant_select_error");
+        logger.error("[VariantHandler] Error handling variant select:", err);
+        await ctx.answerCallbackQuery({ text: t("variant.change_error_callback") }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with available variants
+ * @param currentVariant Current variant for highlighting
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns InlineKeyboard with variant selection buttons
+ */
+export async function buildVariantSelectionMenu(currentVariant, providerID, modelID) {
+    const keyboard = new InlineKeyboard();
+    const variants = await getAvailableVariants(providerID, modelID);
+    if (variants.length === 0) {
+        logger.warn("[VariantHandler] No variants found");
+        return keyboard;
+    }
+    // Filter only active variants (not disabled)
+    const activeVariants = variants.filter((v) => !v.disabled);
+    if (activeVariants.length === 0) {
+        logger.warn("[VariantHandler] No active variants found");
+        // If no active variants, show default at least
+        keyboard.text(`✅ ${formatVariantForDisplay("default")}`, "variant:default").row();
+        return keyboard;
+    }
+    // Add button for each variant (one per row)
+    activeVariants.forEach((variant) => {
+        const isActive = variant.id === currentVariant;
+        const label = formatVariantForDisplay(variant.id);
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `variant:${variant.id}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show variant selection menu
+ * @param ctx grammY context
+ */
+export async function showVariantSelectionMenu(ctx) {
+    try {
+        const currentModel = getStoredModel();
+        if (!currentModel.providerID || !currentModel.modelID) {
+            await ctx.reply(t("variant.select_model_first"));
+            return;
+        }
+        const currentVariant = getCurrentVariant();
+        const keyboard = await buildVariantSelectionMenu(currentVariant, currentModel.providerID, currentModel.modelID);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("variant.menu.empty"));
+            return;
+        }
+        const displayName = formatVariantForDisplay(currentVariant);
+        const text = t("variant.menu.current", { name: displayName });
+        await replyWithInlineMenu(ctx, {
+            menuKind: "variant",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[VariantHandler] Error showing variant menu:", err);
+        await ctx.reply(t("variant.menu.error"));
+    }
+}