@grinev/opencode-telegram-bot 0.6.1 → 0.8.0

package/dist/bot/index.js

@@ -33,23 +33,22 @@ import { questionManager } from "../question/manager.js";
 import { interactionManager } from "../interaction/manager.js";
 import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.js";
-import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
+import { subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
-import { formatSummary, formatToolInfo } from "../summary/formatter.js";
+import { formatSummary, formatToolInfo, getAssistantParseMode } from "../summary/formatter.js";
 import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
-import { opencodeClient } from "../opencode/client.js";
-import { clearSession, getCurrentSession, setCurrentSession } from "../session/manager.js";
+import { getCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
-import { getCurrentProject } from "../settings/manager.js";
-import { getStoredAgent } from "../agent/manager.js";
-import { getStoredModel } from "../model/manager.js";
-import { formatVariantForButton } from "../variant/manager.js";
-import { createMainKeyboard } from "./utils/keyboard.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
-import { formatErrorDetails } from "../utils/error-format.js";
 import { pinnedMessageManager } from "../pinned/manager.js";
 import { t } from "../i18n/index.js";
+import { processUserPrompt } from "./handlers/prompt.js";
+import { handleVoiceMessage } from "./handlers/voice.js";
+import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
+import { sendMessageWithMarkdownFallback } from "./utils/send-with-markdown-fallback.js";
+import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
+import { getStoredModel } from "../model/manager.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
@@ -150,24 +149,19 @@ async function ensureEventSubscription(directory) {
         await toolMessageBatcher.flushSession(sessionId, "assistant_message_completed");
         try {
             const parts = formatSummary(messageText);
+            const assistantParseMode = getAssistantParseMode();
             logger.debug(`[Bot] Sending completed message to Telegram (chatId=${chatIdInstance}, parts=${parts.length})`);
             for (let i = 0; i < parts.length; i++) {
                 const isLastPart = i === parts.length - 1;
-                if (isLastPart && keyboardManager.isInitialized()) {
-                    // Attach updated keyboard to the last message part (only if initialized)
-                    const keyboard = keyboardManager.getKeyboard();
-                    if (keyboard) {
-                        await botInstance.api.sendMessage(chatIdInstance, parts[i], {
-                            reply_markup: keyboard,
-                        });
-                    }
-                    else {
-                        await botInstance.api.sendMessage(chatIdInstance, parts[i]);
-                    }
-                }
-                else {
-                    await botInstance.api.sendMessage(chatIdInstance, parts[i]);
-                }
+                const keyboard = isLastPart && keyboardManager.isInitialized() ? keyboardManager.getKeyboard() : undefined;
+                const options = keyboard ? { reply_markup: keyboard } : undefined;
+                await sendMessageWithMarkdownFallback({
+                    api: botInstance.api,
+                    chatId: chatIdInstance,
+                    text: parts[i],
+                    options,
+                    parseMode: assistantParseMode,
+                });
             }
         }
         catch (err) {
@@ -310,6 +304,25 @@ async function ensureEventSubscription(directory) {
             logger.error("[Bot] Error reloading context after compaction:", err);
         }
     });
+    summaryAggregator.setOnSessionError(async (sessionId, message) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        await toolMessageBatcher.flushSession(sessionId, "session_error");
+        const normalizedMessage = message.trim() || t("common.unknown_error");
+        const truncatedMessage = normalizedMessage.length > 3500
+            ? `${normalizedMessage.slice(0, 3497)}...`
+            : normalizedMessage;
+        await botInstance.api
+            .sendMessage(chatIdInstance, t("bot.session_error", { message: truncatedMessage }))
+            .catch((err) => {
+            logger.error("[Bot] Failed to send session.error message:", err);
+        });
+    });
     summaryAggregator.setOnSessionDiff(async (_sessionId, diffs) => {
         if (!pinnedMessageManager.isInitialized()) {
             return;
@@ -353,41 +366,6 @@ async function ensureEventSubscription(directory) {
         logger.error("Failed to subscribe to events:", err);
     });
 }
-async function isSessionBusy(sessionId, directory) {
-    try {
-        const { data, error } = await opencodeClient.session.status({ directory });
-        if (error || !data) {
-            logger.warn("[Bot] Failed to check session status before prompt:", error);
-            return false;
-        }
-        const sessionStatus = data[sessionId];
-        if (!sessionStatus) {
-            return false;
-        }
-        logger.debug(`[Bot] Current session status before prompt: ${sessionStatus.type || "unknown"}`);
-        return sessionStatus.type === "busy";
-    }
-    catch (err) {
-        logger.warn("[Bot] Error checking session status before prompt:", err);
-        return false;
-    }
-}
-async function resetMismatchedSessionContext() {
-    stopEventListening();
-    summaryAggregator.clear();
-    clearAllInteractionState("session_mismatch_reset");
-    clearSession();
-    keyboardManager.clearContext();
-    if (!pinnedMessageManager.isInitialized()) {
-        return;
-    }
-    try {
-        await pinnedMessageManager.clear();
-    }
-    catch (err) {
-        logger.error("[Bot] Failed to clear pinned message during session reset:", err);
-    }
-}
 export function createBot() {
     clearAllInteractionState("bot_startup");
     toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
@@ -591,6 +569,70 @@ export function createBot() {
             logger.warn("[Bot] Could not clear global commands:", result.error);
         },
     });
+    // Voice and audio message handlers (STT transcription -> prompt)
+    const voicePromptDeps = { bot, ensureEventSubscription };
+    bot.on("message:voice", async (ctx) => {
+        logger.debug(`[Bot] Received voice message, chatId=${ctx.chat.id}`);
+        botInstance = bot;
+        chatIdInstance = ctx.chat.id;
+        await handleVoiceMessage(ctx, voicePromptDeps);
+    });
+    bot.on("message:audio", async (ctx) => {
+        logger.debug(`[Bot] Received audio message, chatId=${ctx.chat.id}`);
+        botInstance = bot;
+        chatIdInstance = ctx.chat.id;
+        await handleVoiceMessage(ctx, voicePromptDeps);
+    });
+    // Photo message handler
+    bot.on("message:photo", async (ctx) => {
+        logger.debug(`[Bot] Received photo message, chatId=${ctx.chat.id}`);
+        const photos = ctx.message?.photo;
+        if (!photos || photos.length === 0) {
+            return;
+        }
+        const caption = ctx.message.caption || "";
+        try {
+            // Get the largest photo (last element in array)
+            const largestPhoto = photos[photos.length - 1];
+            // Check model capabilities
+            const storedModel = getStoredModel();
+            const capabilities = await getModelCapabilities(storedModel.providerID, storedModel.modelID);
+            if (!supportsInput(capabilities, "image")) {
+                logger.warn(`[Bot] Model ${storedModel.providerID}/${storedModel.modelID} doesn't support image input`);
+                await ctx.reply(t("bot.photo_model_no_image"));
+                // Fall back to caption-only if present
+                if (caption.trim().length > 0) {
+                    botInstance = bot;
+                    chatIdInstance = ctx.chat.id;
+                    const promptDeps = { bot, ensureEventSubscription };
+                    await processUserPrompt(ctx, caption, promptDeps);
+                }
+                return;
+            }
+            // Download photo
+            await ctx.reply(t("bot.photo_downloading"));
+            const downloadedFile = await downloadTelegramFile(ctx.api, largestPhoto.file_id);
+            // Convert to data URI (Telegram always converts photos to JPEG)
+            const dataUri = toDataUri(downloadedFile.buffer, "image/jpeg");
+            // Create file part
+            const filePart = {
+                type: "file",
+                mime: "image/jpeg",
+                filename: "photo.jpg",
+                url: dataUri,
+            };
+            logger.info(`[Bot] Sending photo (${downloadedFile.buffer.length} bytes) with prompt`);
+            botInstance = bot;
+            chatIdInstance = ctx.chat.id;
+            // Send via processUserPrompt with file part
+            const promptDeps = { bot, ensureEventSubscription };
+            await processUserPrompt(ctx, caption, promptDeps, [filePart]);
+        }
+        catch (err) {
+            logger.error("[Bot] Error handling photo message:", err);
+            await ctx.reply(t("bot.photo_download_error"));
+        }
+    });
     bot.on("message:text", async (ctx) => {
         const text = ctx.message?.text;
         if (!text) {
@@ -607,145 +649,10 @@ export function createBot() {
         if (handledRename) {
             return;
         }
-        const currentProject = getCurrentProject();
-        if (!currentProject) {
-            await ctx.reply(t("bot.project_not_selected"));
-            return;
-        }
         botInstance = bot;
         chatIdInstance = ctx.chat.id;
-        // Initialize pinned message manager if not already
-        if (!pinnedMessageManager.isInitialized()) {
-            pinnedMessageManager.initialize(bot.api, ctx.chat.id);
-        }
-        // Initialize keyboard manager if not already
-        keyboardManager.initialize(bot.api, ctx.chat.id);
-        let currentSession = getCurrentSession();
-        if (currentSession && currentSession.directory !== currentProject.worktree) {
-            logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
-            await resetMismatchedSessionContext();
-            await ctx.reply(t("bot.session_reset_project_mismatch"));
-            return;
-        }
-        if (!currentSession) {
-            await ctx.reply(t("bot.creating_session"));
-            const { data: session, error } = await opencodeClient.session.create({
-                directory: currentProject.worktree,
-            });
-            if (error || !session) {
-                await ctx.reply(t("bot.create_session_error"));
-                return;
-            }
-            logger.info(`[Bot] Created new session: id=${session.id}, title="${session.title}", project=${currentProject.worktree}`);
-            currentSession = {
-                id: session.id,
-                title: session.title,
-                directory: currentProject.worktree,
-            };
-            setCurrentSession(currentSession);
-            await ingestSessionInfoForCache(session);
-            // Create pinned message for new session
-            try {
-                await pinnedMessageManager.onSessionChange(session.id, session.title);
-            }
-            catch (err) {
-                logger.error("[Bot] Error creating pinned message for new session:", err);
-            }
-            const currentAgent = getStoredAgent();
-            const currentModel = getStoredModel();
-            const contextInfo = pinnedMessageManager.getContextInfo();
-            const variantName = formatVariantForButton(currentModel.variant || "default");
-            const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
-            await ctx.reply(t("bot.session_created", { title: session.title }), {
-                reply_markup: keyboard,
-            });
-        }
-        else {
-            logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
-            // Ensure pinned message exists for existing session
-            if (!pinnedMessageManager.getState().messageId) {
-                try {
-                    await pinnedMessageManager.onSessionChange(currentSession.id, currentSession.title);
-                }
-                catch (err) {
-                    logger.error("[Bot] Error creating pinned message for existing session:", err);
-                }
-            }
-        }
-        await ensureEventSubscription(currentSession.directory);
-        summaryAggregator.setSession(currentSession.id);
-        summaryAggregator.setBotAndChatId(bot, ctx.chat.id);
-        const sessionIsBusy = await isSessionBusy(currentSession.id, currentSession.directory);
-        if (sessionIsBusy) {
-            logger.info(`[Bot] Ignoring new prompt: session ${currentSession.id} is busy`);
-            await ctx.reply(t("bot.session_busy"));
-            return;
-        }
-        try {
-            const currentAgent = getStoredAgent();
-            const storedModel = getStoredModel();
-            const promptOptions = {
-                sessionID: currentSession.id,
-                directory: currentSession.directory,
-                parts: [{ type: "text", text }],
-                agent: currentAgent,
-            };
-            // Use stored model (from settings or config)
-            if (storedModel.providerID && storedModel.modelID) {
-                promptOptions.model = {
-                    providerID: storedModel.providerID,
-                    modelID: storedModel.modelID,
-                };
-                // Add variant if specified
-                if (storedModel.variant) {
-                    promptOptions.variant = storedModel.variant;
-                }
-            }
-            const promptErrorLogContext = {
-                sessionId: currentSession.id,
-                directory: currentSession.directory,
-                agent: currentAgent || "default",
-                modelProvider: storedModel.providerID || "default",
-                modelId: storedModel.modelID || "default",
-                variant: storedModel.variant || "default",
-                promptLength: text.length,
-            };
-            logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}...`);
-            // CRITICAL: DO NOT wait for session.prompt to complete.
-            // If we wait, the handler will not finish and grammY will not call getUpdates,
-            // which blocks receiving button callback_query updates.
-            // The processing result will arrive via SSE events.
-            safeBackgroundTask({
-                taskName: "session.prompt",
-                task: () => opencodeClient.session.prompt(promptOptions),
-                onSuccess: ({ error }) => {
-                    if (error) {
-                        const details = formatErrorDetails(error, 6000);
-                        logger.error("[Bot] OpenCode API returned an error for session.prompt", promptErrorLogContext);
-                        logger.error("[Bot] session.prompt error details:", details);
-                        logger.error("[Bot] session.prompt raw API error object:", error);
-                        // Send user-friendly error via API directly because ctx is no longer available
-                        void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
-                        return;
-                    }
-                    logger.info("[Bot] session.prompt completed");
-                },
-                onError: (error) => {
-                    const details = formatErrorDetails(error, 6000);
-                    logger.error("[Bot] session.prompt background task failed", promptErrorLogContext);
-                    logger.error("[Bot] session.prompt background failure details:", details);
-                    logger.error("[Bot] session.prompt raw background error object:", error);
-                    void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
-                },
-            });
-        }
-        catch (err) {
-            logger.error("Error in prompt handler:", err);
-            if (interactionManager.getSnapshot()) {
-                clearAllInteractionState("message_handler_error");
-            }
-            await ctx.reply(t("error.generic"));
-        }
+        const promptDeps = { bot, ensureEventSubscription };
+        await processUserPrompt(ctx, text, promptDeps);
         logger.debug("[Bot] message:text handler completed (prompt sent in background)");
     });
     bot.catch((err) => {

package/dist/bot/utils/file-download.js

@@ -0,0 +1,75 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_FILE_URL_BASE = "https://api.telegram.org/file/bot";
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
+/**
+ * Download a photo from Telegram servers
+ * @param api Grammy API instance
+ * @param fileId Telegram file_id
+ * @returns Downloaded photo buffer and path
+ */
+export async function downloadTelegramFile(api, fileId) {
+    logger.debug(`[FileDownload] Getting file info for fileId=${fileId}`);
+    const file = await api.getFile(fileId);
+    if (!file.file_path) {
+        throw new Error("File path not available from Telegram");
+    }
+    if (file.file_size && file.file_size > MAX_FILE_SIZE_BYTES) {
+        const sizeMb = (file.file_size / (1024 * 1024)).toFixed(2);
+        throw new Error(`File too large: ${sizeMb}MB (max 20MB)`);
+    }
+    const fileUrl = `${TELEGRAM_FILE_URL_BASE}${config.telegram.token}/${file.file_path}`;
+    logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
+    const fetchOptions = {};
+    // Use proxy if configured
+    if (config.telegram.proxyUrl) {
+        const { HttpsProxyAgent } = await import("https-proxy-agent");
+        fetchOptions.agent = new HttpsProxyAgent(config.telegram.proxyUrl);
+    }
+    const response = await fetch(fileUrl, fetchOptions);
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    logger.debug(`[FileDownload] Downloaded ${buffer.length} bytes`);
+    return {
+        buffer,
+        filePath: file.file_path,
+    };
+}
+/**
+ * Convert buffer to base64 data URI
+ * @param buffer File buffer
+ * @param mimeType MIME type (e.g., "image/jpeg")
+ * @returns Data URI string
+ */
+export function toDataUri(buffer, mimeType) {
+    const base64 = buffer.toString("base64");
+    return `data:${mimeType};base64,${base64}`;
+}
+/**
+ * Check if photo size is within limits
+ * @param fileSize Photo size in bytes
+ * @param maxSizeKb Maximum size in KB (from config)
+ * @returns true if within limit
+ */
+export function isFileSizeAllowed(fileSize, maxSizeKb) {
+    if (!fileSize) {
+        return true; // Unknown size, allow (will be checked on download)
+    }
+    const maxBytes = maxSizeKb * 1024;
+    return fileSize <= maxBytes;
+}
+/**
+ * Get human-readable photo size
+ */
+export function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -0,0 +1,58 @@
+import { logger } from "../../utils/logger.js";
+const MARKDOWN_PARSE_ERROR_MARKERS = [
+    "can't parse entities",
+    "can't parse entity",
+    "can't find end of the entity",
+    "entity beginning",
+    "bad request: can't parse",
+];
+function getErrorText(error) {
+    const parts = [];
+    if (error instanceof Error) {
+        parts.push(error.message);
+    }
+    if (typeof error === "object" && error !== null) {
+        const description = Reflect.get(error, "description");
+        if (typeof description === "string") {
+            parts.push(description);
+        }
+        const message = Reflect.get(error, "message");
+        if (typeof message === "string") {
+            parts.push(message);
+        }
+    }
+    if (typeof error === "string") {
+        parts.push(error);
+    }
+    if (parts.length === 0) {
+        return "";
+    }
+    return parts.join("\n").toLowerCase();
+}
+export function isTelegramMarkdownParseError(error) {
+    const errorText = getErrorText(error);
+    if (!errorText) {
+        return false;
+    }
+    return MARKDOWN_PARSE_ERROR_MARKERS.some((marker) => errorText.includes(marker));
+}
+export async function sendMessageWithMarkdownFallback({ api, chatId, text, options, parseMode, }) {
+    if (!parseMode) {
+        await api.sendMessage(chatId, text, options);
+        return;
+    }
+    const markdownOptions = {
+        ...(options || {}),
+        parse_mode: parseMode,
+    };
+    try {
+        await api.sendMessage(chatId, text, markdownOptions);
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        logger.warn("[Bot] MarkdownV2 parse failed, retrying assistant message in raw mode", error);
+        await api.sendMessage(chatId, text, options);
+    }
+}

package/dist/config.js

@@ -62,6 +62,17 @@ function getOptionalBooleanEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "raw" || normalized === "markdown") {
+        return normalized;
+    }
+    return defaultValue;
+}
 export const config = {
     telegram: {
         token: getEnvVar("TELEGRAM_BOT_TOKEN"),
@@ -82,12 +93,20 @@ export const config = {
     },
     bot: {
         sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
+        projectsListLimit: getOptionalPositiveIntEnvVar("PROJECTS_LIST_LIMIT", 10),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
         serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
         hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
+        messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
     },
     files: {
         maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),
     },
+    stt: {
+        apiUrl: getEnvVar("STT_API_URL", false),
+        apiKey: getEnvVar("STT_API_KEY", false),
+        model: getEnvVar("STT_MODEL", false) || "whisper-large-v3-turbo",
+        language: getEnvVar("STT_LANGUAGE", false),
+    },
 };

package/dist/i18n/en.js

@@ -41,7 +41,13 @@ export const en = {
     "bot.session_busy": "⏳ Agent is already running a task. Wait for completion or use /stop to interrupt current run.",
     "bot.session_reset_project_mismatch": "⚠️ Active session does not match the selected project, so it was reset. Use /sessions to pick one or /new to create a new session.",
     "bot.prompt_send_error": "Failed to send request to OpenCode.",
+    "bot.session_error": "🔴 OpenCode returned an error: {message}",
     "bot.unknown_command": "⚠️ Unknown command: {command}. Use /help to see available commands.",
+    "bot.photo_downloading": "⏳ Downloading photo...",
+    "bot.photo_too_large": "⚠️ Photo is too large (max {maxSizeMb}MB)",
+    "bot.photo_model_no_image": "⚠️ Current model doesn't support image input. Sending text only.",
+    "bot.photo_download_error": "🔴 Failed to download photo",
+    "bot.photo_no_caption": "💡 Tip: Add a caption to describe what you want to do with this photo.",
     "status.header_running": "🟢 **OpenCode Server is running**",
     "status.health.healthy": "Healthy",
     "status.health.unhealthy": "Unhealthy",
@@ -114,6 +120,7 @@ export const en = {
     "model.change_error_callback": "Failed to change model",
     "model.menu.empty": "⚠️ No available models",
     "model.menu.current": "Current model: {name}\n\nSelect model:",
+    "model.menu.favorites_hint": "ℹ️ The model list is built from favorites in OpenCode CLI.",
     "model.menu.error": "🔴 Failed to get models list",
     "variant.model_not_selected_callback": "Error: model is not selected",
     "variant.changed_callback": "Variant changed: {name}",
@@ -229,4 +236,9 @@ export const en = {
     "legacy.models.no_provider_models": "  ⚠️ No available models\n",
     "legacy.models.env_hint": "💡 To use model in .env:\n",
     "legacy.models.error": "🔴 An error occurred while loading models list.",
+    "stt.recognizing": "🎤 Recognizing audio...",
+    "stt.recognized": "🎤 Recognized:\n{text}",
+    "stt.not_configured": "🎤 Voice recognition is not configured.\n\nSet STT_API_URL and STT_API_KEY in .env to enable it.",
+    "stt.error": "🔴 Failed to recognize audio: {error}",
+    "stt.empty_result": "🎤 No speech detected in the audio message.",
 };

package/dist/i18n/ru.js

@@ -41,7 +41,13 @@ export const ru = {
     "bot.session_busy": "⏳ Агент уже выполняет задачу. Дождитесь завершения или используйте /stop, чтобы прервать текущий запуск.",
     "bot.session_reset_project_mismatch": "⚠️ Активная сессия не соответствует выбранному проекту, поэтому была сброшена. Используйте /sessions для выбора или /new для создания новой сессии.",
     "bot.prompt_send_error": "Не удалось отправить запрос в OpenCode.",
+    "bot.session_error": "🔴 OpenCode вернул ошибку: {message}",
     "bot.unknown_command": "⚠️ Неизвестная команда: {command}. Используйте /help для списка команд.",
+    "bot.photo_downloading": "⏳ Скачиваю фото...",
+    "bot.photo_too_large": "⚠️ Фото слишком большое (макс. {maxSizeMb}МБ)",
+    "bot.photo_model_no_image": "⚠️ Текущая модель не поддерживает изображения. Отправляю только текст.",
+    "bot.photo_download_error": "🔴 Не удалось скачать фото",
+    "bot.photo_no_caption": "💡 Совет: Добавьте подпись, чтобы описать, что делать с этим фото.",
     "status.header_running": "🟢 **OpenCode Server запущен**",
     "status.health.healthy": "Healthy",
     "status.health.unhealthy": "Unhealthy",
@@ -114,6 +120,7 @@ export const ru = {
     "model.change_error_callback": "Ошибка при смене модели",
     "model.menu.empty": "⚠️ Нет доступных моделей",
     "model.menu.current": "Текущая модель: {name}\n\nВыберите модель:",
+    "model.menu.favorites_hint": "ℹ️ Список моделей формируется из favorites в OpenCode CLI.",
     "model.menu.error": "🔴 Не удалось получить список моделей",
     "variant.model_not_selected_callback": "Ошибка: модель не выбрана",
     "variant.changed_callback": "Variant изменен: {name}",
@@ -229,4 +236,9 @@ export const ru = {
     "legacy.models.no_provider_models": "  ⚠️ Нет доступных моделей\n",
     "legacy.models.env_hint": "💡 Для использования модели в .env:\n",
     "legacy.models.error": "🔴 Произошла ошибка при получении списка моделей.",
+    "stt.recognizing": "🎤 Распознаю аудио...",
+    "stt.recognized": "🎤 Распознано:\n{text}",
+    "stt.not_configured": "🎤 Распознавание голоса не настроено.\n\nУстановите STT_API_URL и STT_API_KEY в .env для включения.",
+    "stt.error": "🔴 Не удалось распознать аудио: {error}",
+    "stt.empty_result": "🎤 В аудиосообщении не обнаружена речь.",
 };

package/dist/interaction/guard.js

@@ -23,6 +23,10 @@ function classifyIncomingInput(ctx) {
         }
         return { inputType: "text" };
     }
+    // Photo, voice, audio, and other non-text messages are classified as "other"
+    if (ctx.message?.photo) {
+        return { inputType: "other" };
+    }
     return { inputType: "other" };
 }
 function getExpectedInputBlockReason(expectedInput) {
@@ -75,7 +79,10 @@ export function resolveInteractionGuardDecision(ctx) {
         return createBlockDecision(inputType, state, "command_not_allowed", command);
     }
     if (state.expectedInput === "mixed") {
-        return createAllowDecision(inputType, state, command);
+        if (inputType === "callback" || inputType === "text") {
+            return createAllowDecision(inputType, state, command);
+        }
+        return createBlockDecision(inputType, state, "expected_text", command);
     }
     if (inputType === "callback" && isAllowedRenameCancelCallback(ctx, state)) {
         return createAllowDecision(inputType, state, command);