@grinev/opencode-telegram-bot 0.14.0 → 0.15.0

package/dist/bot/index.js

@@ -23,6 +23,7 @@ import { renameCommand, handleRenameCancel, handleRenameTextAnswer } from "./com
 import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands/task.js";
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
+import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
 import { handleAgentSelect, showAgentSelectionMenu } from "./handlers/agent.js";
@@ -43,13 +44,15 @@ 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";
+import { clearPromptResponseMode, processUserPrompt } from "./handlers/prompt.js";
 import { handleVoiceMessage } from "./handlers/voice.js";
 import { handleDocumentMessage } from "./handlers/document.js";
 import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
+import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
 import { sendBotText } from "./utils/telegram-text.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
@@ -63,7 +66,7 @@ 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 = "🧩";
@@ -93,7 +96,7 @@ function prepareStreamingPayload(messageText) {
     }
     return {
         parts,
-        format: config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw",
+        format: "raw",
     };
 }
 const toolMessageBatcher = new ToolMessageBatcher({
@@ -241,6 +244,12 @@ const toolCallStreamer = new ToolCallStreamer({
         });
     },
 });
+function getToolStreamKey(tool) {
+    if (tool === "todowrite") {
+        return "todo";
+    }
+    return "default";
+}
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -296,6 +305,7 @@ async function ensureEventSubscription(directory) {
     summaryAggregator.setOnComplete(async (sessionId, messageId, messageText) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending message");
+            clearPromptResponseMode(sessionId);
             responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
             toolCallStreamer.clearSession(sessionId, "bot_context_missing");
             foregroundSessionState.markIdle(sessionId);
@@ -303,6 +313,7 @@ async function ensureEventSubscription(directory) {
         }
         const currentSession = getCurrentSession();
         if (currentSession?.id !== sessionId) {
+            clearPromptResponseMode(sessionId);
             responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
             toolCallStreamer.clearSession(sessionId, "session_mismatch");
             foregroundSessionState.markIdle(sessionId);
@@ -323,13 +334,15 @@ 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,
                     });
@@ -345,8 +358,15 @@ async function ensureEventSubscription(directory) {
                     }
                 },
             });
+            await sendTtsResponseForSession({
+                api: botApi,
+                sessionId,
+                chatId,
+                text: messageText,
+            });
         }
         catch (err) {
+            clearPromptResponseMode(sessionId);
             logger.error("Failed to send message to Telegram:", err);
             // Stop processing events after critical error to prevent infinite loop
             logger.error("[Bot] CRITICAL: Stopping event processing due to error");
@@ -376,7 +396,7 @@ async function ensureEventSubscription(directory) {
         try {
             const message = formatToolInfo(toolInfo);
             if (message) {
-                toolCallStreamer.append(toolInfo.sessionId, message);
+                toolCallStreamer.append(toolInfo.sessionId, message, getToolStreamKey(toolInfo.tool));
             }
         }
         catch (err) {
@@ -399,7 +419,7 @@ async function ensureEventSubscription(directory) {
             if (!renderedCards) {
                 return;
             }
-            toolCallStreamer.replaceByPrefix(sessionId, SUBAGENT_STREAM_PREFIX, renderedCards);
+            toolCallStreamer.replaceByPrefix(sessionId, SUBAGENT_STREAM_PREFIX, renderedCards, "subagent");
         }
         catch (err) {
             logger.error("Failed to render subagent activity for Telegram:", err);
@@ -550,11 +570,13 @@ async function ensureEventSubscription(directory) {
     });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
         if (!botInstance || !chatIdInstance) {
+            clearPromptResponseMode(sessionId);
             foregroundSessionState.markIdle(sessionId);
             return;
         }
         const currentSession = getCurrentSession();
         if (!currentSession || currentSession.id !== sessionId) {
+            clearPromptResponseMode(sessionId);
             responseStreamer.clearSession(sessionId, "session_error_not_current");
             toolCallStreamer.clearSession(sessionId, "session_error_not_current");
             foregroundSessionState.markIdle(sessionId);
@@ -562,6 +584,7 @@ async function ensureEventSubscription(directory) {
             return;
         }
         responseStreamer.clearSession(sessionId, "session_error");
+        clearPromptResponseMode(sessionId);
         await Promise.all([
             toolMessageBatcher.flushSession(sessionId, "session_error"),
             toolCallStreamer.flushSession(sessionId, "session_error"),
@@ -675,11 +698,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;
@@ -703,6 +732,7 @@ export function createBot() {
     bot.command("start", startCommand);
     bot.command("help", helpCommand);
     bot.command("status", statusCommand);
+    bot.command("tts", ttsCommand);
     bot.command("opencode_start", opencodeStartCommand);
     bot.command("opencode_stop", opencodeStopCommand);
     bot.command("projects", projectsCommand);
@@ -759,9 +789,9 @@ export function createBot() {
             await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
         }
     });
-    // Handle Reply Keyboard button press (agent mode indicator)
+    // Handle Reply Keyboard button press (agent indicator)
     bot.hears(AGENT_MODE_BUTTON_TEXT_PATTERN, async (ctx) => {
-        logger.debug(`[Bot] Agent mode button pressed: ${ctx.message?.text}`);
+        logger.debug(`[Bot] Agent button pressed: ${ctx.message?.text}`);
         try {
             if (await blockMenuWhileInteractionActive(ctx)) {
                 return;

package/dist/bot/message-patterns.js

@@ -1,4 +1,4 @@
-export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\sMode$/;
-export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\sMode$)[\s\S]+$/;
+export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\s(?:Mode|Agent)$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\s(?:Mode|Agent)$)[\s\S]+$/;
 // Keep support for both legacy "💭" and current "💡" prefix.
 export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/bot/streaming/tool-call-streamer.js

@@ -1,5 +1,6 @@
 import { logger } from "../../utils/logger.js";
 const TELEGRAM_MESSAGE_SAFE_LENGTH = 4000;
+const DEFAULT_STREAM_KEY = "default";
 function getErrorMessage(error) {
     if (error instanceof Error) {
         return error.message;
@@ -68,23 +69,23 @@ export class ToolCallStreamer {
         this.editText = options.editText;
         this.deleteText = options.deleteText;
     }
-    append(sessionId, text) {
+    append(sessionId, text, streamKey = DEFAULT_STREAM_KEY) {
         const normalizedText = text.trim();
         if (!sessionId || !normalizedText) {
             return;
         }
-        const state = this.getOrCreateState(sessionId);
+        const state = this.getOrCreateState(sessionId, streamKey);
         state.entries.push({ text: normalizedText });
         state.latestParts = buildParts(state.entries);
         this.ensureTimer(state);
     }
-    replaceByPrefix(sessionId, prefix, text) {
+    replaceByPrefix(sessionId, prefix, text, streamKey = DEFAULT_STREAM_KEY) {
         const normalizedPrefix = prefix.trim();
         const normalizedText = text.trim();
         if (!sessionId || !normalizedPrefix || !normalizedText) {
             return;
         }
-        const state = this.getOrCreateState(sessionId);
+        const state = this.getOrCreateState(sessionId, streamKey);
         const existingEntry = state.entries.find((entry) => entry.prefix === normalizedPrefix);
         if (existingEntry) {
             existingEntry.text = normalizedText;
@@ -96,24 +97,21 @@ export class ToolCallStreamer {
         this.ensureTimer(state);
     }
     async flushSession(sessionId, reason) {
-        const state = this.states.get(sessionId);
-        if (!state) {
-            return;
-        }
-        this.clearTimer(state);
-        await this.enqueueTask(state, () => this.syncState(state, reason));
+        const states = this.getStatesForSession(sessionId);
+        await Promise.all(states.map(async (state) => {
+            this.clearTimer(state);
+            await this.enqueueTask(state, () => this.syncState(state, reason));
+        }));
     }
     async breakSession(sessionId, reason) {
-        const state = this.states.get(sessionId);
-        if (!state) {
-            return;
+        const states = this.getStatesForSession(sessionId);
+        for (const state of states) {
+            state.isBreaking = true;
+            this.clearTimer(state);
+            await this.enqueueTask(state, () => this.syncState(state, reason));
+            this.cancelState(state);
+            this.removeState(state);
         }
-        state.isBreaking = true;
-        this.getOrCreateState(sessionId);
-        this.clearTimer(state);
-        await this.enqueueTask(state, () => this.syncState(state, reason));
-        this.cancelState(state);
-        this.removeState(state);
         logger.debug(`[ToolCallStreamer] Broke session stream: session=${sessionId}, reason=${reason}`);
     }
     clearSession(sessionId, reason) {
@@ -141,8 +139,15 @@ export class ToolCallStreamer {
             logger.debug(`[ToolCallStreamer] Cleared all streams: count=${count}, reason=${reason}`);
         }
     }
-    getOrCreateState(sessionId) {
-        const existing = this.states.get(sessionId);
+    getStateId(sessionId, streamKey) {
+        return `${sessionId}:${streamKey}`;
+    }
+    getStatesForSession(sessionId) {
+        return Array.from(this.allStates).filter((state) => state.sessionId === sessionId);
+    }
+    getOrCreateState(sessionId, streamKey = DEFAULT_STREAM_KEY) {
+        const stateId = this.getStateId(sessionId, streamKey);
+        const existing = this.states.get(stateId);
         if (existing && !existing.isBroken && !existing.cancelled && !existing.isBreaking) {
             return existing;
         }
@@ -151,6 +156,7 @@ export class ToolCallStreamer {
             this.removeState(existing);
         }
         const state = {
+            key: streamKey,
             sessionId,
             entries: [],
             latestParts: [],
@@ -164,7 +170,7 @@ export class ToolCallStreamer {
             fatalErrorMessage: null,
             fatalErrorLogged: false,
         };
-        this.states.set(sessionId, state);
+        this.states.set(stateId, state);
         this.allStates.add(state);
         return state;
     }
@@ -202,8 +208,9 @@ export class ToolCallStreamer {
         this.clearTimer(state);
     }
     removeState(state) {
-        if (this.states.get(state.sessionId) === state) {
-            this.states.delete(state.sessionId);
+        const stateId = this.getStateId(state.sessionId, state.key);
+        if (this.states.get(stateId) === state) {
+            this.states.delete(stateId);
         }
         this.allStates.delete(state);
     }

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

@@ -1,5 +1,5 @@
 import { logger } from "../../utils/logger.js";
-export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, formatRawSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
     let streamedMessageIds = [];
     const preparedStreamPayload = prepareStreamingPayload(messageText);
     if (preparedStreamPayload) {
@@ -22,11 +22,14 @@ export async function finalizeAssistantResponse({ sessionId, messageId, messageT
         }
     }
     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/keyboard.js

@@ -1,5 +1,5 @@
 import { Keyboard } from "grammy";
-import { getAgentDisplayName } from "../../agent/types.js";
+import { getAgentButtonLabel } from "../../agent/types.js";
 import { formatModelForButton } from "../../model/types.js";
 import { t } from "../../i18n/index.js";
 /**
@@ -33,7 +33,7 @@ function formatContextForButton(contextInfo) {
  */
 export function createMainKeyboard(currentAgent, currentModel, contextInfo, variantName) {
     const keyboard = new Keyboard();
-    const agentText = getAgentDisplayName(currentAgent);
+    const agentText = getAgentButtonLabel(currentAgent);
     // Format model with compact provider/model text and icon
     const modelText = formatModelForButton(currentModel.providerID, currentModel.modelID);
     // Context text - show "0" if no data available
@@ -49,15 +49,15 @@ export function createMainKeyboard(currentAgent, currentModel, contextInfo, vari
     return keyboard.resized().persistent();
 }
 /**
- * Create Reply Keyboard with agent mode indicator
+ * Create Reply Keyboard with agent indicator
  * @param currentAgent Current agent name (e.g., "build", "plan")
- * @returns Reply Keyboard with single button showing current mode
+ * @returns Reply Keyboard with single button showing current agent
  * @deprecated Use createMainKeyboard instead
  */
 export function createAgentKeyboard(currentAgent) {
     const keyboard = new Keyboard();
-    const displayName = getAgentDisplayName(currentAgent);
-    // Single button with current agent mode
+    const displayName = getAgentButtonLabel(currentAgent);
+    // Single button with current agent
     keyboard.text(displayName).row();
     return keyboard.resized().persistent();
 }

package/dist/bot/utils/send-tts-response.js

@@ -0,0 +1,37 @@
+import { InputFile } from "grammy";
+import { consumePromptResponseMode } from "../handlers/prompt.js";
+import { isTtsConfigured, synthesizeSpeech } from "../../tts/client.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+const MAX_TTS_INPUT_CHARS = 4_000;
+export async function sendTtsResponseForSession({ api, sessionId, chatId, text, consumeResponseMode: consumeResponseModeImpl = consumePromptResponseMode, isTtsConfigured: isTtsConfiguredImpl = isTtsConfigured, synthesizeSpeech: synthesizeSpeechImpl = synthesizeSpeech, }) {
+    const responseMode = consumeResponseModeImpl(sessionId);
+    if (responseMode !== "text_and_tts") {
+        return false;
+    }
+    const normalizedText = text.trim();
+    if (!normalizedText) {
+        return false;
+    }
+    if (!isTtsConfiguredImpl()) {
+        logger.info(`[TTS] Skipping audio reply for session ${sessionId}: TTS is not configured`);
+        return false;
+    }
+    if (normalizedText.length > MAX_TTS_INPUT_CHARS) {
+        logger.warn(`[TTS] Skipping audio reply for session ${sessionId}: text length ${normalizedText.length} exceeds limit ${MAX_TTS_INPUT_CHARS}`);
+        return false;
+    }
+    try {
+        const speech = await synthesizeSpeechImpl(normalizedText);
+        await api.sendAudio(chatId, new InputFile(speech.buffer, speech.filename));
+        logger.info(`[TTS] Sent audio reply for session ${sessionId}`);
+        return true;
+    }
+    catch (error) {
+        logger.warn(`[TTS] Failed to send audio reply for session ${sessionId}`, error);
+        await api.sendMessage(chatId, t("tts.failed")).catch((sendError) => {
+            logger.warn(`[TTS] Failed to send audio error message for session ${sessionId}`, sendError);
+        });
+        return false;
+    }
+}

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

@@ -6,6 +6,50 @@ 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;
@@ -47,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);
     }
@@ -55,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);
     }
@@ -62,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, stripMarkdownFormattingOptions(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);
     }
@@ -74,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);
     }
@@ -81,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, stripMarkdownFormattingOptions(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/config.js

@@ -73,6 +73,8 @@ 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),
+        bashToolDisplayMaxLength: getOptionalPositiveIntEnvVar("BASH_TOOL_DISPLAY_MAX_LENGTH", 128),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
         hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
@@ -87,4 +89,10 @@ export const config = {
         model: getEnvVar("STT_MODEL", false) || "whisper-large-v3-turbo",
         language: getEnvVar("STT_LANGUAGE", false),
     },
+    tts: {
+        apiUrl: getEnvVar("TTS_API_URL", false),
+        apiKey: getEnvVar("TTS_API_KEY", false),
+        model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
+        voice: getEnvVar("TTS_VOICE", false) || "alloy",
+    },
 };

package/dist/i18n/de.js

@@ -3,6 +3,7 @@ export const de = {
     "cmd.description.new": "Neue Sitzung erstellen",
     "cmd.description.stop": "Aktuelle Aktion stoppen",
     "cmd.description.sessions": "Sitzungen auflisten",
+    "cmd.description.tts": "Audioantworten umschalten",
     "cmd.description.projects": "Projekte auflisten",
     "cmd.description.task": "Geplante Aufgabe erstellen",
     "cmd.description.tasklist": "Geplante Aufgaben anzeigen",
@@ -32,8 +33,8 @@ export const de = {
     "inline.cancelled_callback": "Abgebrochen",
     "common.unknown": "unbekannt",
     "common.unknown_error": "unbekannter Fehler",
-    "start.welcome": "👋 Willkommen beim OpenCode Telegram Bot!\n\nNutze Befehle:\n/projects — Projekt auswählen\n/sessions — Sitzungsliste\n/new — neue Sitzung\n/task — geplante Aufgabe\n/tasklist — geplante Aufgaben\n/status — Status\n/help — Hilfe\n\nNutze die unteren Buttons, um Modus, Modell und Variante zu wählen.",
-    "help.keyboard_hint": "💡 Nutze die unteren Buttons für Modus, Modell, Variante und Kontextaktionen.",
+    "start.welcome": "👋 Willkommen beim OpenCode Telegram Bot!\n\nNutze Befehle:\n/projects — Projekt auswählen\n/sessions — Sitzungsliste\n/new — neue Sitzung\n/task — geplante Aufgabe\n/tasklist — geplante Aufgaben\n/status — Status\n/help — Hilfe\n\nNutze die unteren Buttons, um Agent, Modell und Variante zu wählen.",
+    "help.keyboard_hint": "💡 Nutze die unteren Buttons für Agent, Modell, Variante und Kontextaktionen.",
     "help.text": "📖 **Hilfe**\n\n/status - Serverstatus prüfen\n/sessions - Sitzungsliste\n/new - Neue Sitzung erstellen\n/help - Hilfe",
     "bot.thinking": "💭 Denke...",
     "bot.project_not_selected": "🏗 Projekt ist nicht ausgewählt.\n\nWähle zuerst ein Projekt mit /projects.",
@@ -65,8 +66,11 @@ export const de = {
     "status.line.managed_no": "Vom Bot gestartet: Nein",
     "status.line.pid": "PID: {pid}",
     "status.line.uptime_sec": "Betriebszeit: {seconds} s",
-    "status.line.mode": "Modus: {mode}",
+    "status.line.mode": "Agent: {mode}",
     "status.line.model": "Modell: {model}",
+    "status.line.tts": "TTS-Antworten: {tts}",
+    "status.tts.on": "Ein",
+    "status.tts.off": "Aus",
     "status.agent_not_set": "nicht gesetzt",
     "status.project_selected": "Projekt: {project}",
     "status.project_not_selected": "Projekt: nicht ausgewählt",
@@ -75,6 +79,10 @@ export const de = {
     "status.session_not_selected": "Aktuelle Sitzung: nicht ausgewählt",
     "status.session_hint": "Nutze /sessions zur Auswahl oder /new zum Erstellen",
     "status.server_unavailable": "🔴 OpenCode-Server ist nicht verfügbar\n\nNutze /opencode_start, um den Server zu starten.",
+    "tts.enabled": "🔊 Audioantworten global aktiviert.",
+    "tts.not_configured": "⚠️ Audioantworten sind nicht verfugbar. Setze zuerst `TTS_API_URL` und `TTS_API_KEY`.",
+    "tts.disabled": "🔇 Audioantworten global deaktiviert.",
+    "tts.failed": "⚠️ Audioreply konnte nicht erzeugt werden.",
     "projects.empty": "📭 Keine Projekte gefunden.\n\nÖffne ein Verzeichnis in OpenCode und erstelle mindestens eine Sitzung, dann erscheint es hier.",
     "projects.select": "Projekt auswählen:",
     "projects.select_with_current": "Projekt auswählen:\n\nAktuell: 🏗 {project}",
@@ -127,11 +135,11 @@ export const de = {
     "opencode_stop.stop_error": "🔴 OpenCode-Server konnte nicht gestoppt werden\n\nFehler: {error}",
     "opencode_stop.success": "✅ OpenCode-Server erfolgreich gestoppt",
     "opencode_stop.error": "🔴 Beim Stoppen des Servers ist ein Fehler aufgetreten.\n\nSiehe Anwendungslogs für Details.",
-    "agent.changed_callback": "Modus geändert: {name}",
-    "agent.changed_message": "✅ Modus geändert zu: {name}",
-    "agent.change_error_callback": "Modus konnte nicht geändert werden",
-    "agent.menu.current": "Aktueller Modus: {name}\n\nModus auswählen:",
-    "agent.menu.select": "Arbeitsmodus auswählen:",
+    "agent.changed_callback": "Agent geändert: {name}",
+    "agent.changed_message": "✅ Agent geändert zu: {name}",
+    "agent.change_error_callback": "Agent konnte nicht geändert werden",
+    "agent.menu.current": "Aktueller Agent: {name}\n\nAgent auswählen:",
+    "agent.menu.select": "Agent auswählen:",
     "agent.menu.empty": "⚠️ Keine verfügbaren Agenten",
     "agent.menu.error": "🔴 Agentenliste konnte nicht geladen werden",
     "model.changed_callback": "Modell geändert: {name}",
@@ -205,7 +213,7 @@ export const de = {
     "question.summary.title": "✅ Umfrage abgeschlossen!\n\n",
     "question.summary.question": "Frage {index}:\n{question}\n\n",
     "question.summary.answer": "Antwort:\n{answer}\n\n",
-    "keyboard.agent_mode": "{emoji} {name} Modus",
+    "keyboard.agent_mode": "{emoji} {name} Agent",
     "keyboard.context": "📊 {used} / {limit} ({percent}%)",
     "keyboard.context_empty": "📊 0",
     "keyboard.variant": "💭 {name}",