@grinev/opencode-telegram-bot 0.14.0 → 0.14.1

package/.env.example

@@ -46,6 +46,10 @@ 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

package/README.md

@@ -147,30 +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`                     |
-| `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`                   |
+| 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/index.js

@@ -43,6 +43,7 @@ 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";
@@ -63,7 +64,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 +94,7 @@ function prepareStreamingPayload(messageText) {
     }
     return {
         parts,
-        format: config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw",
+        format: "raw",
     };
 }
 const toolMessageBatcher = new ToolMessageBatcher({
@@ -323,13 +324,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,
                     });
@@ -675,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/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/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,7 @@ 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"),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
         hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),

package/dist/pinned/manager.js

@@ -23,6 +23,11 @@ class PinnedMessageManager {
     };
     contextLimit = null;
     onKeyboardUpdateCallback;
+    updateDebounceTimer = null;
+    updateTask = null;
+    pendingUpdate = false;
+    pendingForceUpdate = false;
+    lastRenderedMessageText = null;
     /**
      * Initialize manager with bot API and chat ID
      */
@@ -58,6 +63,9 @@ class PinnedMessageManager {
         }
         // Reset changed files for new session
         this.state.changedFiles = [];
+        this.lastRenderedMessageText = null;
+        this.pendingUpdate = false;
+        this.pendingForceUpdate = false;
         // Unpin old message and create new one
         await this.unpinOldMessage();
         await this.createPinnedMessage();
@@ -163,12 +171,16 @@ class PinnedMessageManager {
      * Used at thinking time to push accumulated silent updates to Telegram.
      */
     async refresh() {
-        await this.updatePinnedMessage();
+        await this.updatePinnedMessage(true);
     }
     /**
      * Called when cost info is received from SSE events
      */
     async onCostUpdate(cost) {
+        if (!Number.isFinite(cost) || cost === 0) {
+            logger.debug("[PinnedManager] Ignoring non-impacting cost update");
+            return;
+        }
         const currentCost = this.state.cost || 0;
         this.state.cost = currentCost + cost;
         logger.debug(`[PinnedManager] Cost added: $${cost.toFixed(2)}, total session: $${(this.state.cost || 0).toFixed(2)}`);
@@ -223,6 +235,10 @@ class PinnedMessageManager {
             logger.debug("[PinnedManager] Ignoring empty session.diff, keeping tool-collected data");
             return;
         }
+        if (this.areFileDiffsEqual(this.state.changedFiles, diffs)) {
+            logger.debug("[PinnedManager] Ignoring unchanged session.diff");
+            return;
+        }
         this.state.changedFiles = diffs;
         logger.debug(`[PinnedManager] Session diff updated: ${diffs.length} files`);
         await this.updatePinnedMessage();
@@ -243,15 +259,14 @@ class PinnedMessageManager {
         // Schedule debounced update (avoid spamming Telegram API on rapid tool events)
         this.scheduleDebouncedUpdate();
     }
-    updateDebounceTimer = null;
     scheduleDebouncedUpdate() {
         if (this.updateDebounceTimer) {
             clearTimeout(this.updateDebounceTimer);
         }
         this.updateDebounceTimer = setTimeout(() => {
             this.updateDebounceTimer = null;
-            this.updatePinnedMessage();
-        }, 500);
+            void this.updatePinnedMessage();
+        }, 1000);
     }
     /**
      * Load file diffs from API for current session.
@@ -430,6 +445,21 @@ class PinnedMessageManager {
             return normalized;
         return ".../" + segments.slice(-3).join("/");
     }
+    areFileDiffsEqual(current, next) {
+        if (current.length !== next.length) {
+            return false;
+        }
+        for (let index = 0; index < current.length; index++) {
+            const left = current[index];
+            const right = next[index];
+            if (left.file !== right.file ||
+                left.additions !== right.additions ||
+                left.deletions !== right.deletions) {
+                return false;
+            }
+        }
+        return true;
+    }
     /**
      * Fetch context limit from current model configuration
      */
@@ -498,6 +528,7 @@ class PinnedMessageManager {
             this.state.messageId = sentMessage.message_id;
             this.state.chatId = this.chatId;
             this.state.lastUpdated = Date.now();
+            this.lastRenderedMessageText = text;
             // Save to settings for persistence
             setPinnedMessageId(sentMessage.message_id);
             // Pin the message (silently)
@@ -513,36 +544,67 @@ class PinnedMessageManager {
     /**
      * Update existing pinned message text
      */
-    async updatePinnedMessage() {
+    async updatePinnedMessage(forceUpdate = false) {
         if (!this.api || !this.chatId || !this.state.messageId) {
             return;
         }
-        try {
-            const text = this.formatMessage();
-            await this.api.editMessageText(this.chatId, this.state.messageId, text);
-            this.state.lastUpdated = Date.now();
-            logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
-            // Trigger keyboard update callback
-            if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
-                setImmediate(() => {
-                    this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
-                });
-            }
+        this.pendingUpdate = true;
+        if (forceUpdate) {
+            this.pendingForceUpdate = true;
         }
-        catch (err) {
-            // Handle "message is not modified" error silently
-            if (err instanceof Error && err.message.includes("message is not modified")) {
+        if (this.updateTask) {
+            await this.updateTask;
+            return;
+        }
+        this.updateTask = this.flushPendingPinnedUpdates().finally(() => {
+            this.updateTask = null;
+        });
+        await this.updateTask;
+    }
+    async flushPendingPinnedUpdates() {
+        while (this.pendingUpdate) {
+            this.pendingUpdate = false;
+            const shouldForceUpdate = this.pendingForceUpdate;
+            this.pendingForceUpdate = false;
+            if (!this.api || !this.chatId || !this.state.messageId) {
                 return;
             }
-            // Handle "message to edit not found" - recreate
-            if (err instanceof Error && err.message.includes("message to edit not found")) {
-                logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
-                this.state.messageId = null;
-                clearPinnedMessageId();
-                await this.createPinnedMessage();
-                return;
+            const text = this.formatMessage();
+            if (!shouldForceUpdate && text === this.lastRenderedMessageText) {
+                logger.debug("[PinnedManager] Skipping pinned update: message content unchanged");
+                continue;
+            }
+            try {
+                await this.api.editMessageText(this.chatId, this.state.messageId, text);
+                this.state.lastUpdated = Date.now();
+                this.lastRenderedMessageText = text;
+                logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
+                // Trigger keyboard update callback
+                if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
+                    setImmediate(() => {
+                        this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
+                    });
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+                // Handle "message is not modified" error silently
+                if (errorMessage.includes("message is not modified")) {
+                    this.lastRenderedMessageText = text;
+                    continue;
+                }
+                // Handle "message to edit not found" - recreate
+                if (errorMessage.includes("message to edit not found")) {
+                    logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
+                    this.state.messageId = null;
+                    this.lastRenderedMessageText = null;
+                    this.pendingForceUpdate = false;
+                    clearPinnedMessageId();
+                    await this.createPinnedMessage();
+                    continue;
+                }
+                logger.error("[PinnedManager] Error updating pinned message:", err);
             }
-            logger.error("[PinnedManager] Error updating pinned message:", err);
         }
     }
     /**
@@ -556,6 +618,9 @@ class PinnedMessageManager {
             // Unpin all messages (ensures clean state)
             await this.api.unpinAllChatMessages(this.chatId).catch(() => { });
             this.state.messageId = null;
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.debug("[PinnedManager] Unpinned old messages");
         }
@@ -586,6 +651,9 @@ class PinnedMessageManager {
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             return;
         }
@@ -600,6 +668,9 @@ class PinnedMessageManager {
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.info("[PinnedManager] Cleared pinned message state");
         }

package/dist/utils/telegram-rate-limit-retry.js

@@ -0,0 +1,93 @@
+function getErrorMessage(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);
+    }
+    return parts.join("\n");
+}
+function getRetryAfterSecondsFromError(error) {
+    if (typeof error === "object" && error !== null) {
+        const parameters = Reflect.get(error, "parameters");
+        if (typeof parameters === "object" && parameters !== null) {
+            const retryAfter = Reflect.get(parameters, "retry_after");
+            if (typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter > 0) {
+                return retryAfter;
+            }
+        }
+    }
+    const message = getErrorMessage(error);
+    const retryMatch = message.match(/retry after\s+(\d+)/i);
+    if (!retryMatch) {
+        return null;
+    }
+    const parsedSeconds = Number.parseInt(retryMatch[1], 10);
+    if (!Number.isFinite(parsedSeconds) || parsedSeconds <= 0) {
+        return null;
+    }
+    return parsedSeconds;
+}
+function isTelegramRateLimitError(error) {
+    if (typeof error === "object" && error !== null) {
+        const status = Reflect.get(error, "status");
+        if (typeof status === "number" && status === 429) {
+            return true;
+        }
+        const errorCode = Reflect.get(error, "error_code");
+        if (typeof errorCode === "number" && errorCode === 429) {
+            return true;
+        }
+    }
+    const message = getErrorMessage(error).toLowerCase();
+    return /\b429\b/.test(message) || message.includes("too many requests");
+}
+function wait(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function getTelegramRetryAfterMs(error, fallbackDelayMs = 1000) {
+    if (!isTelegramRateLimitError(error)) {
+        return null;
+    }
+    const retryAfterSeconds = getRetryAfterSecondsFromError(error);
+    if (retryAfterSeconds !== null) {
+        return retryAfterSeconds * 1000;
+    }
+    return Math.max(1, Math.floor(fallbackDelayMs));
+}
+export async function withTelegramRateLimitRetry(operation, options) {
+    const maxRetries = Math.max(0, Math.floor(options?.maxRetries ?? 3));
+    const fallbackDelayMs = options?.fallbackDelayMs ?? 1000;
+    let attempt = 0;
+    while (true) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const retryAfterMs = getTelegramRetryAfterMs(error, fallbackDelayMs);
+            if (retryAfterMs === null || attempt >= maxRetries) {
+                throw error;
+            }
+            attempt += 1;
+            options?.onRetry?.({
+                attempt,
+                retryAfterMs,
+                error,
+            });
+            await wait(retryAfterMs);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",