@grinev/opencode-telegram-bot 0.7.0 → 0.8.0

package/.env.example

@@ -54,6 +54,11 @@ OPENCODE_MODEL_ID=big-pickle
 # Hide tool call service messages (default: false)
 # HIDE_TOOL_CALL_MESSAGES=false
 
+# Assistant message formatting mode (default: markdown)
+# markdown = convert assistant replies to Telegram MarkdownV2
+# raw = show assistant replies as plain text
+# MESSAGE_FORMAT_MODE=markdown
+
 # Code File Settings (optional)
 # Maximum file size in KB to send as document (default: 100)
 # CODE_FILE_MAX_SIZE_KB=100

package/README.md

@@ -28,6 +28,7 @@ Quick start: `npx @grinev/opencode-telegram-bot`
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, then forward recognized text to OpenCode
 - **Context control** — compact context when it gets too large, right from the chat
 - **Input flow control** — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions
+- **Configurable reply formatting** — assistant replies use Telegram MarkdownV2 by default, with optional raw mode (`MESSAGE_FORMAT_MODE=markdown|raw`)
 - **Security** — strict user ID whitelist; no one else can access your bot, even if they find it
 - **Localization** — English and Russian UI (`BOT_LOCALE=en|ru`)
 
@@ -134,6 +135,7 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `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`                  |
+| `MESSAGE_FORMAT_MODE`           | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                   |    No    | `markdown`               |
 | `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                    |
 | `STT_API_URL`                   | Whisper-compatible API base URL (enables voice/audio transcription)                                          |    No    | —                        |
 | `STT_API_KEY`                   | API key for your STT provider                                                                                |    No    | —                        |

package/dist/bot/handlers/model.js

@@ -7,8 +7,20 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { getStoredAgent } from "../../agent/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
+import { config } from "../../config.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
 import { t } from "../../i18n/index.js";
+function isOnlyConfigDefaultModel(models) {
+    if (models.length !== 1) {
+        return false;
+    }
+    const defaultProviderID = config.opencode.model.provider;
+    const defaultModelID = config.opencode.model.modelId;
+    if (!defaultProviderID || !defaultModelID) {
+        return false;
+    }
+    return models[0].providerID === defaultProviderID && models[0].modelID === defaultModelID;
+}
 /**
  * Handle model selection callback
  * @param ctx grammY context
@@ -83,9 +95,9 @@ export async function handleModelSelect(ctx) {
  * @param currentModel Current model for highlighting
  * @returns InlineKeyboard with model selection buttons
  */
-export async function buildModelSelectionMenu(currentModel) {
+export async function buildModelSelectionMenu(currentModel, favoriteModels) {
     const keyboard = new InlineKeyboard();
-    const favorites = await getFavoriteModels();
+    const favorites = favoriteModels ?? (await getFavoriteModels());
     if (favorites.length === 0) {
         logger.warn("[ModelHandler] No favorite models found");
         return keyboard;
@@ -109,7 +121,8 @@ export async function buildModelSelectionMenu(currentModel) {
 export async function showModelSelectionMenu(ctx) {
     try {
         const currentModel = fetchCurrentModel();
-        const keyboard = await buildModelSelectionMenu(currentModel);
+        const favorites = await getFavoriteModels();
+        const keyboard = await buildModelSelectionMenu(currentModel, favorites);
         if (keyboard.inline_keyboard.length === 0) {
             await ctx.reply(t("model.menu.empty"));
             return;
@@ -121,6 +134,9 @@ export async function showModelSelectionMenu(ctx) {
             text,
             keyboard,
         });
+        if (isOnlyConfigDefaultModel(favorites)) {
+            await ctx.reply(t("model.menu.favorites_hint"));
+        }
     }
     catch (err) {
         logger.error("[ModelHandler] Error showing model menu:", err);

package/dist/bot/handlers/prompt.js

@@ -62,11 +62,15 @@ async function resetMismatchedSessionContext() {
 }
 /**
  * Processes a user prompt: ensures project/session, subscribes to events, and sends
- * the prompt to OpenCode. Used by both text and voice message handlers.
+ * the prompt to OpenCode. Used by text, voice, and photo message handlers.
  *
+ * @param ctx - Grammy context
+ * @param text - Text content of the prompt
+ * @param deps - Dependencies (bot and event subscription)
+ * @param fileParts - Optional file parts (for photo/document attachments)
  * @returns true if the prompt was dispatched, false if it was blocked/failed early.
  */
-export async function processUserPrompt(ctx, text, deps) {
+export async function processUserPrompt(ctx, text, deps, fileParts = []) {
     const { bot, ensureEventSubscription } = deps;
     const currentProject = getCurrentProject();
     if (!currentProject) {
@@ -145,10 +149,25 @@ export async function processUserPrompt(ctx, text, deps) {
     try {
         const currentAgent = getStoredAgent();
         const storedModel = getStoredModel();
+        // Build parts array with text and files
+        const parts = [];
+        // Add text part if present
+        if (text.trim().length > 0) {
+            parts.push({ type: "text", text });
+        }
+        // Add file parts
+        parts.push(...fileParts);
+        // If no text and files exist, use a placeholder
+        if (parts.length === 0 || (parts.length > 0 && parts.every((p) => p.type === "file"))) {
+            if (fileParts.length > 0) {
+                // Files without text - add a minimal system prompt
+                parts.unshift({ type: "text", text: "See attached file" });
+            }
+        }
         const promptOptions = {
             sessionID: currentSession.id,
             directory: currentSession.directory,
-            parts: [{ type: "text", text }],
+            parts,
             agent: currentAgent,
         };
         // Use stored model (from settings or config)
@@ -170,8 +189,9 @@ export async function processUserPrompt(ctx, text, deps) {
             modelId: storedModel.modelID || "default",
             variant: storedModel.variant || "default",
             promptLength: text.length,
+            fileCount: fileParts.length,
         };
-        logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}...`);
+        logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         // 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.

package/dist/bot/index.js

@@ -35,7 +35,7 @@ import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.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 { getCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
@@ -45,6 +45,10 @@ 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;
@@ -145,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) {
@@ -584,6 +583,56 @@ export function createBot() {
         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) {

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"),
@@ -87,6 +98,7 @@ export const config = {
         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),

package/dist/i18n/en.js

@@ -43,6 +43,11 @@ export const en = {
     "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",
@@ -115,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}",

package/dist/i18n/ru.js

@@ -43,6 +43,11 @@ export const ru = {
     "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",
@@ -115,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}",

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) {

package/dist/model/capabilities.js

@@ -0,0 +1,62 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const capabilitiesCache = {};
+/**
+ * Get model capabilities from OpenCode API
+ * Results are cached in memory per model
+ */
+export async function getModelCapabilities(providerID, modelID) {
+    const cacheKey = `${providerID}/${modelID}`;
+    if (capabilitiesCache[cacheKey] !== undefined) {
+        logger.debug(`[ModelCapabilities] Cache hit for ${cacheKey}`);
+        return capabilitiesCache[cacheKey];
+    }
+    try {
+        logger.debug(`[ModelCapabilities] Fetching capabilities for ${cacheKey}`);
+        const response = await opencodeClient.config.providers();
+        if (response.error || !response.data) {
+            logger.error("[ModelCapabilities] API returned error:", response.error);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const providers = response.data.providers;
+        const provider = providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[ModelCapabilities] Provider ${providerID} not found`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[ModelCapabilities] Model ${cacheKey} not found in provider`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        logger.debug(`[ModelCapabilities] Found capabilities for ${cacheKey}`);
+        capabilitiesCache[cacheKey] = model.capabilities;
+        return model.capabilities;
+    }
+    catch (error) {
+        logger.error("[ModelCapabilities] Failed to fetch providers:", error);
+        capabilitiesCache[cacheKey] = null;
+        return null;
+    }
+}
+/**
+ * Check if model supports a specific input type
+ */
+export function supportsInput(capabilities, inputType) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.input[inputType] === true;
+}
+/**
+ * Check if model supports attachments in general
+ */
+export function supportsAttachment(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.attachment === true;
+}

package/dist/summary/formatter.js

@@ -1,4 +1,5 @@
 import * as path from "path";
+import { convert } from "telegram-markdown-v2";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
@@ -22,6 +23,87 @@ function splitText(text, maxLength) {
     }
     return parts;
 }
+function isCodeFenceLine(line) {
+    return line.trimStart().startsWith("```");
+}
+function isHorizontalRuleLine(line) {
+    const normalized = line.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /^([-*_])(?:\s*\1){2,}$/.test(normalized);
+}
+function isHeadingLine(line) {
+    return /^\s{0,3}#{1,6}\s+\S/.test(line);
+}
+function normalizeHeadingLine(line) {
+    const match = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
+    if (!match) {
+        return line;
+    }
+    return `**${match[1]}**`;
+}
+function normalizeChecklistLine(line) {
+    const match = line.match(/^(\s*)(?:[-+*]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const marker = match[2].toLowerCase() === "x" ? "✅" : "🔲";
+    return `${match[1]}${marker} ${match[3]}`;
+}
+function preprocessMarkdownForTelegram(text) {
+    const lines = text.split("\n");
+    const output = [];
+    let inCodeFence = false;
+    let inQuote = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (isCodeFenceLine(line)) {
+            inCodeFence = !inCodeFence;
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (inCodeFence) {
+            output.push(line);
+            continue;
+        }
+        if (!line.trim()) {
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (isHeadingLine(line)) {
+            output.push(normalizeHeadingLine(line));
+            inQuote = false;
+            continue;
+        }
+        if (isHorizontalRuleLine(line)) {
+            output.push("──────────");
+            inQuote = false;
+            continue;
+        }
+        const trimmedLeft = line.trimStart();
+        if (trimmedLeft.startsWith(">")) {
+            inQuote = true;
+            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
+            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
+            output.push(normalizedChecklistInQuote ? `> ${normalizedChecklistInQuote.trimStart()}` : trimmedLeft);
+            continue;
+        }
+        const normalizedChecklist = normalizeChecklistLine(line);
+        if (normalizedChecklist) {
+            output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
+            continue;
+        }
+        if (inQuote) {
+            output.push(`> ${trimmedLeft}`);
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
 export function normalizePathForDisplay(filePath) {
     const normalizedPath = filePath.replace(/\\/g, "/");
     const project = getCurrentProject();
@@ -44,6 +126,25 @@ export function normalizePathForDisplay(filePath) {
     return normalizedPath;
 }
 export function formatSummary(text) {
+    return formatSummaryWithMode(text, config.bot.messageFormatMode);
+}
+export function getAssistantParseMode() {
+    if (config.bot.messageFormatMode === "markdown") {
+        return "MarkdownV2";
+    }
+    return undefined;
+}
+function formatMarkdownForTelegram(text) {
+    try {
+        const preprocessed = preprocessMarkdownForTelegram(text);
+        return convert(preprocessed, "keep");
+    }
+    catch (error) {
+        logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
+        return text;
+    }
+}
+export function formatSummaryWithMode(text, mode) {
     if (!text || text.trim().length === 0) {
         return [];
     }
@@ -54,6 +155,17 @@ export function formatSummary(text) {
         if (!trimmed) {
             continue;
         }
+        if (mode === "markdown") {
+            const converted = formatMarkdownForTelegram(trimmed);
+            const convertedParts = splitText(converted, TELEGRAM_MESSAGE_LIMIT);
+            for (const convertedPart of convertedParts) {
+                const normalizedPart = convertedPart.trim();
+                if (normalizedPart) {
+                    formattedParts.push(normalizedPart);
+                }
+            }
+            continue;
+        }
         if (parts.length > 1) {
             formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,7 +57,8 @@
     "dotenv": "^17.2.3",
     "grammy": "^1.39.2",
     "https-proxy-agent": "^7.0.6",
-    "socks-proxy-agent": "^8.0.5"
+    "socks-proxy-agent": "^8.0.5",
+    "telegram-markdown-v2": "^0.0.4"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",