@grinev/opencode-telegram-bot 0.13.2 → 0.14.1

package/.env.example

@@ -46,24 +46,20 @@ OPENCODE_MODEL_ID=big-pickle
 # Maximum number of scheduled tasks allowed at once (default: 10)
 # TASK_LIMIT=10
 
+# Stream update throttle in milliseconds for assistant/tool message edits (default: 500)
+# Higher value = fewer Telegram edit requests, lower value = more real-time updates
+# RESPONSE_STREAM_THROTTLE_MS=500
+
 # Bot locale: supported locale code (default: en)
 # Supported locales: en, de, es, fr, ru, zh
 # BOT_LOCALE=en
 
-# Service message batching interval in seconds (thinking + tool calls, default: 5)
-# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
-# 0 = send immediately (can hit rate limits if there are many tool calls)
-# SERVICE_MESSAGES_INTERVAL_SEC=5
-
 # Hide thinking indicator messages (default: false)
 # HIDE_THINKING_MESSAGES=false
 
 # Hide tool call service messages (default: false)
 # HIDE_TOOL_CALL_MESSAGES=false
 
-# Stream assistant responses while they are being generated (default: true)
-# RESPONSE_STREAMING=true
-
 # Assistant message formatting mode (default: markdown)
 # markdown = convert assistant replies to Telegram MarkdownV2
 # raw = show assistant replies as plain text

package/README.md

@@ -28,6 +28,7 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 - **Live status** — pinned message with current project, model, context usage, and changed files list, updated in real time
 - **Model switching** — pick models from OpenCode favorites and recent history directly in the chat (favorites are shown first)
 - **Agent modes** — switch between Plan and Build modes on the fly
+- **Subagent activity** — watch live subagent progress in chat, including the current task, agent, model, and active tool step
 - **Custom Commands** — run OpenCode custom commands (and built-ins like `init`/`review`) from an inline menu with confirmation
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, then forward recognized text to OpenCode
@@ -146,32 +147,31 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                        | Description                                                                                                  | Required | Default                  |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ------------------------ |
-| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                        |
-| `TELEGRAM_ALLOWED_USER_ID`      | Your numeric Telegram user ID                                                                                |   Yes    | —                        |
-| `TELEGRAM_PROXY_URL`            | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                     |    No    | —                        |
-| `OPENCODE_API_URL`              | OpenCode server URL                                                                                          |    No    | `http://localhost:4096`  |
-| `OPENCODE_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`               |
-| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                        |
-| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`               |
-| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`             |
-| `BOT_LOCALE`                    | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                             |    No    | `en`                     |
-| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
-| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    No    | `10`                     |
-| `COMMANDS_LIST_LIMIT`           | Commands per page in `/commands`                                                                             |    No    | `10`                     |
-| `TASK_LIMIT`                    | Maximum number of scheduled tasks that can exist at once                                                     |    No    | `10`                     |
-| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
-| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                  |
-| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                  |
-| `RESPONSE_STREAMING`            | Stream assistant replies while they are generated across one or more Telegram messages                       |    No    | `true`                   |
-| `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    | —                        |
-| `STT_MODEL`                     | STT model name passed to `/audio/transcriptions`                                                             |    No    | `whisper-large-v3-turbo` |
-| `STT_LANGUAGE`                  | Optional language hint (empty = provider auto-detect)                                                        |    No    | —                        |
-| `LOG_LEVEL`                     | Log level (`debug`, `info`, `warn`, `error`)                                                                 |    No    | `info`                   |
+| Variable                      | Description                                                                      | Required | Default                  |
+| ----------------------------- | -------------------------------------------------------------------------------- | :------: | ------------------------ |
+| `TELEGRAM_BOT_TOKEN`          | Bot token from @BotFather                                                        |   Yes    | —                        |
+| `TELEGRAM_ALLOWED_USER_ID`    | Your numeric Telegram user ID                                                    |   Yes    | —                        |
+| `TELEGRAM_PROXY_URL`          | Proxy URL for Telegram API (SOCKS5/HTTP)                                         |    No    | —                        |
+| `OPENCODE_API_URL`            | OpenCode server URL                                                              |    No    | `http://localhost:4096`  |
+| `OPENCODE_SERVER_USERNAME`    | Server auth username                                                             |    No    | `opencode`               |
+| `OPENCODE_SERVER_PASSWORD`    | Server auth password                                                             |    No    | —                        |
+| `OPENCODE_MODEL_PROVIDER`     | Default model provider                                                           |   Yes    | `opencode`               |
+| `OPENCODE_MODEL_ID`           | Default model ID                                                                 |   Yes    | `big-pickle`             |
+| `BOT_LOCALE`                  | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`) |    No    | `en`                     |
+| `SESSIONS_LIST_LIMIT`         | Sessions per page in `/sessions`                                                 |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`         | Projects per page in `/projects`                                                 |    No    | `10`                     |
+| `COMMANDS_LIST_LIMIT`         | Commands per page in `/commands`                                                 |    No    | `10`                     |
+| `TASK_LIMIT`                  | Maximum number of scheduled tasks that can exist at once                         |    No    | `10`                     |
+| `RESPONSE_STREAM_THROTTLE_MS` | Stream edit throttle (ms) for assistant and tool updates                         |    No    | `500`                    |
+| `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    | —                        |
+| `STT_MODEL`                   | STT model name passed to `/audio/transcriptions`                                 |    No    | `whisper-large-v3-turbo` |
+| `STT_LANGUAGE`                | Optional language hint (empty = provider auto-detect)                            |    No    | —                        |
+| `LOG_LEVEL`                   | Log level (`debug`, `info`, `warn`, `error`)                                     |    No    | `info`                   |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 

package/dist/bot/commands/sessions.js

@@ -51,6 +51,7 @@ async function loadSessionPage(directory, page, pageSize) {
     const { data: sessions, error } = await opencodeClient.session.list({
         directory,
         limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
+        roots: true,
     });
     if (error || !sessions) {
         throw error || new Error("No data received from server");

package/dist/bot/index.js

@@ -37,11 +37,13 @@ import { keyboardManager } from "../keyboard/manager.js";
 import { subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatSummaryWithMode, formatToolInfo, getAssistantParseMode, } from "../summary/formatter.js";
+import { renderSubagentCards } from "../summary/subagent-formatter.js";
 import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { getCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
+import { withTelegramRateLimitRetry } from "../utils/telegram-rate-limit-retry.js";
 import { pinnedMessageManager } from "../pinned/manager.js";
 import { t } from "../i18n/index.js";
 import { processUserPrompt } from "./handlers/prompt.js";
@@ -62,9 +64,10 @@ let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
-const RESPONSE_STREAM_THROTTLE_MS = 200;
+const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
 const SESSION_RETRY_PREFIX = "🔁";
+const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
@@ -91,11 +94,10 @@ function prepareStreamingPayload(messageText) {
     }
     return {
         parts,
-        format: config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw",
+        format: "raw",
     };
 }
 const toolMessageBatcher = new ToolMessageBatcher({
-    intervalSeconds: 5,
     sendText: async (sessionId, text) => {
         if (!botInstance || !chatIdInstance) {
             return;
@@ -270,7 +272,6 @@ async function ensureEventSubscription(directory) {
         logger.error("No directory found for event subscription");
         return;
     }
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
     summaryAggregator.setTypingIndicatorEnabled(true);
     summaryAggregator.setOnCleared(() => {
         toolMessageBatcher.clearAll("summary_aggregator_clear");
@@ -278,9 +279,6 @@ async function ensureEventSubscription(directory) {
         responseStreamer.clearAll("summary_aggregator_clear");
     });
     summaryAggregator.setOnPartial((sessionId, messageId, messageText) => {
-        if (!config.bot.responseStreaming) {
-            return;
-        }
         if (!botInstance || !chatIdInstance) {
             return;
         }
@@ -292,7 +290,7 @@ async function ensureEventSubscription(directory) {
         if (!preparedStreamPayload) {
             return;
         }
-        preparedStreamPayload.sendOptions = undefined;
+        preparedStreamPayload.sendOptions = { disable_notification: true };
         preparedStreamPayload.editOptions = undefined;
         responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
     });
@@ -315,8 +313,7 @@ async function ensureEventSubscription(directory) {
         const botApi = botInstance.api;
         const chatId = chatIdInstance;
         try {
-            const streamedViaMessages = await finalizeAssistantResponse({
-                responseStreaming: config.bot.responseStreaming,
+            await finalizeAssistantResponse({
                 sessionId,
                 messageId,
                 messageText,
@@ -327,24 +324,30 @@ async function ensureEventSubscription(directory) {
                 ]).then(() => undefined),
                 prepareStreamingPayload,
                 formatSummary,
+                formatRawSummary: (text) => formatSummaryWithMode(text, "raw"),
                 resolveFormat: () => (getAssistantParseMode() === "MarkdownV2" ? "markdown_v2" : "raw"),
                 getReplyKeyboard: getCurrentReplyKeyboard,
-                sendText: async (text, options, format) => {
+                sendText: async (text, rawFallbackText, options, format) => {
                     await sendBotText({
                         api: botApi,
                         chatId,
                         text,
+                        rawFallbackText,
                         options: options,
                         format,
                     });
                 },
+                deleteMessages: async (messageIds) => {
+                    for (const msgId of messageIds) {
+                        try {
+                            await botApi.deleteMessage(chatId, msgId);
+                        }
+                        catch (err) {
+                            logger.warn(`[Bot] Failed to delete streamed message ${msgId}:`, err);
+                        }
+                    }
+                },
             });
-            if (streamedViaMessages) {
-                logger.debug(`[Bot] Final assistant message already streamed (session=${sessionId}, message=${messageId})`);
-                foregroundSessionState.markIdle(sessionId);
-                await scheduledTaskRuntime.flushDeferredDeliveries();
-                return;
-            }
         }
         catch (err) {
             logger.error("Failed to send message to Telegram:", err);
@@ -368,7 +371,9 @@ async function ensureEventSubscription(directory) {
         }
         const shouldIncludeToolInfoInFileCaption = toolInfo.hasFileAttachment &&
             (toolInfo.tool === "write" || toolInfo.tool === "edit" || toolInfo.tool === "apply_patch");
-        if (config.bot.hideToolCallMessages || shouldIncludeToolInfoInFileCaption) {
+        if (config.bot.hideToolCallMessages ||
+            shouldIncludeToolInfoInFileCaption ||
+            toolInfo.tool === "task") {
             return;
         }
         try {
@@ -381,6 +386,28 @@ async function ensureEventSubscription(directory) {
             logger.error("Failed to send tool notification to Telegram:", err);
         }
     });
+    summaryAggregator.setOnSubagent(async (sessionId, subagents) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        if (config.bot.hideToolCallMessages) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        try {
+            const renderedCards = await renderSubagentCards(subagents);
+            if (!renderedCards) {
+                return;
+            }
+            toolCallStreamer.replaceByPrefix(sessionId, SUBAGENT_STREAM_PREFIX, renderedCards);
+        }
+        catch (err) {
+            logger.error("Failed to render subagent activity for Telegram:", err);
+        }
+    });
     summaryAggregator.setOnToolFile(async (fileInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending file");
@@ -463,24 +490,38 @@ async function ensureEventSubscription(directory) {
         logger.debug("[Bot] Agent started thinking");
         await toolCallStreamer.breakSession(sessionId, "thinking_started");
         deliverThinkingMessage(sessionId, toolMessageBatcher, {
-            responseStreaming: config.bot.responseStreaming,
             hideThinkingMessages: config.bot.hideThinkingMessages,
         });
+        // Refresh pinned message so it shows the latest in-memory context
+        // (accumulated from silent token updates). 1 API call per thinking event.
+        if (pinnedMessageManager.isInitialized()) {
+            await pinnedMessageManager.refresh();
+        }
     });
-    summaryAggregator.setOnTokens(async (tokens) => {
+    summaryAggregator.setOnTokens(async (tokens, isCompleted) => {
         if (!pinnedMessageManager.isInitialized()) {
             return;
         }
         try {
-            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}`);
-            // Update keyboardManager SYNCHRONOUSLY before any await
-            // This ensures keyboard has correct context when onComplete sends the reply
+            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}, completed=${isCompleted}`);
             const contextSize = tokens.input + tokens.cacheRead;
             const contextLimit = pinnedMessageManager.getContextLimit();
+            // Skip non-completed messages with zero context: a new assistant message
+            // starts with tokens={input:0, ...} which would overwrite valid context
+            // from the previous step. Only accept zeros from completed messages.
+            if (!isCompleted && contextSize === 0) {
+                logger.debug("[Bot] Skipping zero-token intermediate update");
+                return;
+            }
+            // Update both keyboard and pinned state in memory (keeps them in sync)
             if (contextLimit > 0) {
                 keyboardManager.updateContext(contextSize, contextLimit);
             }
-            await pinnedMessageManager.onMessageComplete(tokens);
+            pinnedMessageManager.updateTokensSilent(tokens);
+            // Full pinned message update (API call) only on completed messages
+            if (isCompleted) {
+                await pinnedMessageManager.onMessageComplete(tokens);
+            }
         }
         catch (err) {
             logger.error("[Bot] Error updating pinned message with tokens:", err);
@@ -600,8 +641,6 @@ async function ensureEventSubscription(directory) {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
-    logger.debug(`[ToolBatcher] Service messages interval: ${config.bot.serviceMessagesIntervalSec}s`);
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;
@@ -639,11 +678,17 @@ export function createBot() {
             const timeSinceLast = now - lastGetUpdatesTime;
             logger.debug(`[Bot API] getUpdates called (${timeSinceLast}ms since last)`);
             lastGetUpdatesTime = now;
+            return prev(method, payload, signal);
         }
-        else if (method === "sendMessage") {
+        if (method === "sendMessage") {
             logger.debug(`[Bot API] sendMessage to chat ${payload.chat_id}`);
         }
-        return prev(method, payload, signal);
+        return withTelegramRateLimitRetry(() => prev(method, payload, signal), {
+            maxRetries: 5,
+            onRetry: ({ attempt, retryAfterMs, error }) => {
+                logger.warn(`[Bot API] Telegram rate limit on ${method}, retrying in ${retryAfterMs}ms (attempt=${attempt})`, error);
+            },
+        });
     });
     bot.use((ctx, next) => {
         const hasCallbackQuery = !!ctx.callbackQuery;

package/dist/bot/streaming/response-streamer.js

@@ -70,9 +70,10 @@ export class ResponseStreamer {
         this.ensureTimer(state);
     }
     async complete(sessionId, messageId, payload, options) {
+        const notStreamed = { streamed: false, telegramMessageIds: [] };
         const state = this.states.get(buildStateKey(sessionId, messageId));
         if (!state) {
-            return false;
+            return notStreamed;
         }
         if (payload) {
             const normalizedPayload = normalizePayload(payload);
@@ -86,12 +87,12 @@ export class ResponseStreamer {
             await this.cleanupBrokenStream(state, "complete_broken_stream");
             this.cancelState(state);
             this.states.delete(state.key);
-            return false;
+            return notStreamed;
         }
         if (state.telegramMessageIds.length === 0) {
             this.cancelState(state);
             this.states.delete(state.key);
-            return false;
+            return notStreamed;
         }
         let synced = true;
         if (options?.flushFinal !== false) {
@@ -100,9 +101,10 @@ export class ResponseStreamer {
                 await this.cleanupBrokenStream(state, "final_sync_failed_cleanup");
             }
         }
+        const messageIds = [...state.telegramMessageIds];
         this.cancelState(state);
         this.states.delete(state.key);
-        return synced;
+        return { streamed: synced, telegramMessageIds: messageIds };
     }
     clearMessage(sessionId, messageId, reason) {
         const key = buildStateKey(sessionId, messageId);

package/dist/bot/utils/finalize-assistant-response.js

@@ -1,23 +1,35 @@
-export async function finalizeAssistantResponse({ responseStreaming, sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, }) {
-    let streamedViaMessages = false;
-    if (responseStreaming) {
-        const preparedStreamPayload = prepareStreamingPayload(messageText);
-        if (preparedStreamPayload) {
-            preparedStreamPayload.sendOptions = undefined;
-            preparedStreamPayload.editOptions = undefined;
-        }
-        streamedViaMessages = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+import { logger } from "../../utils/logger.js";
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, formatRawSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
+    let streamedMessageIds = [];
+    const preparedStreamPayload = prepareStreamingPayload(messageText);
+    if (preparedStreamPayload) {
+        preparedStreamPayload.sendOptions = { disable_notification: true };
+        preparedStreamPayload.editOptions = undefined;
+    }
+    const result = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+    if (result.streamed) {
+        streamedMessageIds = result.telegramMessageIds;
     }
     await flushPendingServiceMessages();
-    if (streamedViaMessages) {
-        return true;
+    // When the response was streamed, delete the streamed messages and re-send
+    // via the non-streamed path so the reply keyboard carries the latest context.
+    if (streamedMessageIds.length > 0) {
+        try {
+            await deleteMessages(streamedMessageIds);
+        }
+        catch (err) {
+            logger.warn("[FinalizeResponse] Failed to delete streamed messages, sending with keyboard anyway:", err);
+        }
     }
     const parts = formatSummary(messageText);
+    const rawParts = formatRawSummary(messageText);
     const format = resolveFormat();
-    for (const part of parts) {
+    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
+        const part = parts[partIndex];
+        const rawFallbackText = rawParts[partIndex];
         const keyboard = getReplyKeyboard();
         const options = keyboard ? { reply_markup: keyboard } : undefined;
-        await sendText(part, options, format);
+        await sendText(part, rawFallbackText, options, format);
     }
     return false;
 }

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

@@ -6,6 +6,61 @@ const MARKDOWN_PARSE_ERROR_MARKERS = [
     "entity beginning",
     "bad request: can't parse",
 ];
+const MARKDOWN_V2_RESERVED_CHARS = new Set([
+    "_",
+    "*",
+    "[",
+    "]",
+    "(",
+    ")",
+    "~",
+    "`",
+    ">",
+    "#",
+    "+",
+    "-",
+    "=",
+    "|",
+    "{",
+    "}",
+    ".",
+    "!",
+    "\\",
+]);
+const MARKDOWN_V2_ESCAPED_CHAR = /\\([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function escapeTelegramMarkdownV2(text) {
+    let result = "";
+    let trailingBackslashes = 0;
+    for (const char of text) {
+        if (char === "\\") {
+            result += char;
+            trailingBackslashes += 1;
+            continue;
+        }
+        const isEscaped = trailingBackslashes % 2 === 1;
+        trailingBackslashes = 0;
+        if (MARKDOWN_V2_RESERVED_CHARS.has(char) && !isEscaped) {
+            result += `\\${char}`;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function unescapeTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_ESCAPED_CHAR, "$1");
+}
+function stripMarkdownFormattingOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const rawOptions = {
+        ...options,
+    };
+    delete rawOptions.parse_mode;
+    delete rawOptions.entities;
+    return rawOptions;
+}
 function getErrorText(error) {
     const parts = [];
     if (error instanceof Error) {
@@ -36,7 +91,7 @@ export function isTelegramMarkdownParseError(error) {
     }
     return MARKDOWN_PARSE_ERROR_MARKERS.some((marker) => errorText.includes(marker));
 }
-export async function sendMessageWithMarkdownFallback({ api, chatId, text, options, parseMode, }) {
+export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFallbackText, options, parseMode, }) {
     if (!parseMode) {
         return api.sendMessage(chatId, text, options);
     }
@@ -44,6 +99,7 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, optio
         ...(options || {}),
         parse_mode: parseMode,
     };
+    const fallbackText = rawFallbackText ?? (parseMode === "MarkdownV2" ? unescapeTelegramMarkdownV2(text) : text);
     try {
         return await api.sendMessage(chatId, text, markdownOptions);
     }
@@ -51,11 +107,27 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, optio
         if (!isTelegramMarkdownParseError(error)) {
             throw error;
         }
+        if (parseMode === "MarkdownV2") {
+            const escapedText = escapeTelegramMarkdownV2(text);
+            if (escapedText !== text) {
+                logger.warn("[Bot] Markdown parse failed, retrying assistant message with escaped MarkdownV2", error);
+                try {
+                    return await api.sendMessage(chatId, escapedText, markdownOptions);
+                }
+                catch (escapedError) {
+                    if (!isTelegramMarkdownParseError(escapedError)) {
+                        throw escapedError;
+                    }
+                    logger.warn("[Bot] Escaped Markdown parse failed, retrying assistant message in raw mode", escapedError);
+                    return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
+                }
+            }
+        }
         logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
-        return api.sendMessage(chatId, text, options);
+        return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
     }
 }
-export async function editMessageWithMarkdownFallback({ api, chatId, messageId, text, options, parseMode, }) {
+export async function editMessageWithMarkdownFallback({ api, chatId, messageId, text, rawFallbackText, options, parseMode, }) {
     if (!parseMode) {
         return api.editMessageText(chatId, messageId, text, options);
     }
@@ -63,6 +135,7 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
         ...(options || {}),
         parse_mode: parseMode,
     };
+    const fallbackText = rawFallbackText ?? (parseMode === "MarkdownV2" ? unescapeTelegramMarkdownV2(text) : text);
     try {
         return await api.editMessageText(chatId, messageId, text, markdownOptions);
     }
@@ -70,7 +143,23 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
         if (!isTelegramMarkdownParseError(error)) {
             throw error;
         }
+        if (parseMode === "MarkdownV2") {
+            const escapedText = escapeTelegramMarkdownV2(text);
+            if (escapedText !== text) {
+                logger.warn("[Bot] Markdown parse failed, retrying edited message with escaped MarkdownV2", error);
+                try {
+                    return await api.editMessageText(chatId, messageId, escapedText, markdownOptions);
+                }
+                catch (escapedError) {
+                    if (!isTelegramMarkdownParseError(escapedError)) {
+                        throw escapedError;
+                    }
+                    logger.warn("[Bot] Escaped Markdown parse failed, retrying edited message in raw mode", escapedError);
+                    return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
+                }
+            }
+        }
         logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
-        return api.editMessageText(chatId, messageId, text, options);
+        return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
     }
 }

package/dist/bot/utils/telegram-text.js

@@ -5,21 +5,23 @@ function resolveParseMode(format) {
     }
     return undefined;
 }
-export async function sendBotText({ api, chatId, text, options, format = "raw", }) {
+export async function sendBotText({ api, chatId, text, rawFallbackText, options, format = "raw", }) {
     await sendMessageWithMarkdownFallback({
         api,
         chatId,
         text,
+        rawFallbackText,
         options,
         parseMode: resolveParseMode(format),
     });
 }
-export async function editBotText({ api, chatId, messageId, text, options, format = "raw", }) {
+export async function editBotText({ api, chatId, messageId, text, rawFallbackText, options, format = "raw", }) {
     await editMessageWithMarkdownFallback({
         api,
         chatId,
         messageId,
         text,
+        rawFallbackText,
         options,
         parseMode: resolveParseMode(format),
     });

package/dist/bot/utils/thinking-message.js

@@ -4,6 +4,5 @@ export function deliverThinkingMessage(sessionId, batcher, options) {
         return;
     }
     const message = t("bot.thinking");
-    void options.responseStreaming;
     batcher.sendTextNow(sessionId, message, "thinking_started");
 }

package/dist/config.js

@@ -21,20 +21,6 @@ function getOptionalPositiveIntEnvVar(key, defaultValue) {
     }
     return parsedValue;
 }
-function getOptionalNonNegativeIntEnvVarFromKeys(keys, defaultValue) {
-    for (const key of keys) {
-        const value = getEnvVar(key, false);
-        if (!value) {
-            continue;
-        }
-        const parsedValue = Number.parseInt(value, 10);
-        if (Number.isNaN(parsedValue) || parsedValue < 0) {
-            return defaultValue;
-        }
-        return parsedValue;
-    }
-    return defaultValue;
-}
 function getOptionalLocaleEnvVar(key, defaultValue) {
     const value = getEnvVar(key, false);
     return normalizeLocale(value, defaultValue);
@@ -87,11 +73,10 @@ export const config = {
         projectsListLimit: getOptionalPositiveIntEnvVar("PROJECTS_LIST_LIMIT", 10),
         commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
         taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
+        responseStreamThrottleMs: getOptionalPositiveIntEnvVar("RESPONSE_STREAM_THROTTLE_MS", 500),
         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),
-        responseStreaming: getOptionalBooleanEnvVar("RESPONSE_STREAMING", true),
         messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
     },
     files: {