@grinev/opencode-telegram-bot 0.5.0 → 0.6.0

package/.env.example

@@ -39,6 +39,17 @@ OPENCODE_MODEL_ID=big-pickle
 # Bot locale: en or ru (default: en)
 # 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
+
 # Code File Settings (optional)
 # Maximum file size in KB to send as document (default: 100)
 # CODE_FILE_MAX_SIZE_KB=100

package/README.md

@@ -122,20 +122,23 @@ 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 (`en` or `ru`)               |    No    | `en`                    |
-| `SESSIONS_LIST_LIMIT`      | Max sessions shown in `/sessions`            |    No    | `10`                    |
-| `CODE_FILE_MAX_SIZE_KB`    | Max file size (KB) to send as document       |    No    | `100`                   |
-| `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 (`en` or `ru`)                                                                               |    No    | `en`                    |
+| `SESSIONS_LIST_LIMIT`           | Max sessions shown in `/sessions`                                                                            |    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`                 |
+| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                   |
+| `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/new.js

@@ -3,6 +3,7 @@ import { setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { getStoredAgent } from "../../agent/manager.js";
@@ -32,6 +33,7 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
         clearAllInteractionState("session_created");
         await ingestSessionInfoForCache(session);
         // Initialize pinned message manager and create pinned message

package/dist/bot/commands/sessions.js

@@ -3,6 +3,7 @@ import { opencodeClient } from "../../opencode/client.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
@@ -84,6 +85,7 @@ export async function handleSessionSelect(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
         clearAllInteractionState("session_switched");
         await ctx.answerCallbackQuery();
         let loadingMessageId = null;

package/dist/bot/handlers/permission.js

@@ -50,6 +50,33 @@ function clearPermissionInteraction(reason) {
         interactionManager.clear(reason);
     }
 }
+function syncPermissionInteractionState(metadata = {}) {
+    const pendingCount = permissionManager.getPendingCount();
+    if (pendingCount === 0) {
+        clearPermissionInteraction("permission_no_pending_requests");
+        return;
+    }
+    const nextMetadata = {
+        pendingCount,
+        ...metadata,
+    };
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.transition({
+            expectedInput: "callback",
+            metadata: nextMetadata,
+        });
+        return;
+    }
+    interactionManager.start({
+        kind: "permission",
+        expectedInput: "callback",
+        metadata: nextMetadata,
+    });
+}
+function isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
 /**
  * Handle permission callback from inline buttons
  */
@@ -71,10 +98,22 @@ export async function handlePermissionCallback(ctx) {
         await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
         return true;
     }
+    const requestID = permissionManager.getRequestID(callbackMessageId);
+    if (!requestID) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
     const parts = data.split(":");
     const action = parts[1];
+    if (!isPermissionReply(action)) {
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+        return true;
+    }
     try {
-        await handlePermissionReply(ctx, action);
+        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
     }
     catch (err) {
         logger.error("[PermissionHandler] Error handling callback:", err);
@@ -88,13 +127,12 @@ export async function handlePermissionCallback(ctx) {
 /**
  * Handle permission reply (once/always/reject)
  */
-async function handlePermissionReply(ctx, reply) {
-    const requestID = permissionManager.getRequestID();
+async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
     const currentProject = getCurrentProject();
     const currentSession = getCurrentSession();
     const chatId = ctx.chat?.id;
     const directory = currentSession?.directory ?? currentProject?.worktree;
-    if (!requestID || !directory || !chatId) {
+    if (!directory || !chatId) {
         permissionManager.clear();
         clearPermissionInteraction("permission_invalid_runtime_context");
         await ctx.answerCallbackQuery({
@@ -134,30 +172,20 @@ async function handlePermissionReply(ctx, reply) {
             logger.info("[PermissionHandler] Permission reply sent successfully");
         },
     });
-    permissionManager.clear();
-    clearPermissionInteraction("permission_replied");
+    permissionManager.removeByMessageId(callbackMessageId);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_replied");
+        return;
+    }
+    syncPermissionInteractionState({
+        lastRepliedRequestID: requestID,
+    });
 }
 /**
  * Show permission request message with inline buttons
  */
 export async function showPermissionRequest(bot, chatId, request) {
     logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
-    const previousMessageId = permissionManager.getMessageId();
-    const hadActivePermission = permissionManager.isActive();
-    if (hadActivePermission && previousMessageId !== null) {
-        logger.debug(`[PermissionHandler] Replacing active permission request, deleting previous message: ${previousMessageId}`);
-        await bot.deleteMessage(chatId, previousMessageId).catch((err) => {
-            logger.debug("[PermissionHandler] Failed to delete previous permission message:", err);
-        });
-    }
-    permissionManager.startPermission(request);
-    interactionManager.start({
-        kind: "permission",
-        expectedInput: "callback",
-        metadata: {
-            requestID: request.id,
-        },
-    });
     const text = formatPermissionText(request);
     const keyboard = buildPermissionKeyboard();
     try {
@@ -166,18 +194,14 @@ export async function showPermissionRequest(bot, chatId, request) {
             parse_mode: "Markdown",
         });
         logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
-        permissionManager.setMessageId(message.message_id);
-        interactionManager.transition({
-            metadata: {
-                requestID: request.id,
-                messageId: message.message_id,
-            },
+        permissionManager.startPermission(request, message.message_id);
+        syncPermissionInteractionState({
+            requestID: request.id,
+            messageId: message.message_id,
         });
         summaryAggregator.stopTypingIndicator();
     }
     catch (err) {
-        permissionManager.clear();
-        clearPermissionInteraction("permission_message_send_failed");
         logger.error("[PermissionHandler] Failed to send permission message:", err);
         throw err;
     }

package/dist/bot/index.js

@@ -36,6 +36,7 @@ import { keyboardManager } from "../keyboard/manager.js";
 import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatToolInfo } from "../summary/formatter.js";
+import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { opencodeClient } from "../opencode/client.js";
 import { clearSession, getCurrentSession, setCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
@@ -52,6 +53,21 @@ import { t } from "../i18n/index.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
+const toolMessageBatcher = new ToolMessageBatcher({
+    intervalSeconds: 5,
+    sendMessage: async (sessionId, text) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        await botInstance.api.sendMessage(chatIdInstance, text, {
+            disable_notification: true,
+        });
+    },
+});
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -82,6 +98,10 @@ async function ensureEventSubscription(directory) {
         logger.error("No directory found for event subscription");
         return;
     }
+    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
+    summaryAggregator.setOnCleared(() => {
+        toolMessageBatcher.clearAll("summary_aggregator_clear");
+    });
     summaryAggregator.setOnComplete(async (sessionId, messageText) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending message");
@@ -91,6 +111,7 @@ async function ensureEventSubscription(directory) {
         if (currentSession?.id !== sessionId) {
             return;
         }
+        await toolMessageBatcher.flushSession(sessionId, "assistant_message_completed");
         try {
             const parts = formatSummary(messageText);
             logger.debug(`[Bot] Sending completed message to Telegram (chatId=${chatIdInstance}, parts=${parts.length})`);
@@ -121,19 +142,21 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnTool(async (toolInfo) => {
+        if (config.bot.hideToolCallMessages) {
+            return;
+        }
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending tool notification");
             return;
         }
         const currentSession = getCurrentSession();
-        const sessionId = summaryAggregator["currentSessionId"];
-        if (!currentSession || currentSession.id !== sessionId) {
+        if (!currentSession || currentSession.id !== toolInfo.sessionId) {
             return;
         }
         try {
             const message = formatToolInfo(toolInfo);
             if (message) {
-                await botInstance.api.sendMessage(chatIdInstance, message);
+                toolMessageBatcher.enqueue(toolInfo.sessionId, message);
             }
         }
         catch (err) {
@@ -159,6 +182,7 @@ async function ensureEventSubscription(directory) {
             await fs.writeFile(tempFilePath, fileData.buffer);
             await botInstance.api.sendDocument(chatIdInstance, new InputFile(tempFilePath), {
                 caption: fileData.caption,
+                disable_notification: true,
             });
             await fs.unlink(tempFilePath);
             logger.debug(`[Bot] Temporary file deleted: ${fileData.filename}`);
@@ -172,6 +196,10 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing questions");
             return;
         }
+        const currentSession = getCurrentSession();
+        if (currentSession) {
+            await toolMessageBatcher.flushSession(currentSession.id, "question_asked");
+        }
         if (questionManager.isActive()) {
             logger.warn("[Bot] Replacing active poll with a new one");
             const previousMessageIds = questionManager.getMessageIds();
@@ -202,17 +230,23 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing permission request");
             return;
         }
+        await toolMessageBatcher.flushSession(request.sessionID, "permission_asked");
         logger.info(`[Bot] Received permission request from agent: type=${request.permission}, requestID=${request.id}`);
         await showPermissionRequest(botInstance.api, chatIdInstance, request);
     });
-    summaryAggregator.setOnThinking(async () => {
+    summaryAggregator.setOnThinking(async (sessionId) => {
+        if (config.bot.hideThinkingMessages) {
+            return;
+        }
         if (!botInstance || !chatIdInstance) {
             return;
         }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
         logger.debug("[Bot] Agent started thinking");
-        await botInstance.api.sendMessage(chatIdInstance, t("bot.thinking")).catch((err) => {
-            logger.error("[Bot] Failed to send thinking message:", err);
-        });
+        toolMessageBatcher.enqueue(sessionId, t("bot.thinking"));
     });
     summaryAggregator.setOnTokens(async (tokens) => {
         if (!pinnedMessageManager.isInitialized()) {
@@ -325,6 +359,8 @@ async function resetMismatchedSessionContext() {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
+    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
+    logger.info(`[ToolBatcher] Service messages interval: ${config.bot.serviceMessagesIntervalSec}s`);
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;

package/dist/config.js

@@ -20,6 +20,20 @@ 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);
     if (!value) {
@@ -34,6 +48,20 @@ function getOptionalLocaleEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+function getOptionalBooleanEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+}
 export const config = {
     telegram: {
         token: getEnvVar("TELEGRAM_BOT_TOKEN"),
@@ -55,6 +83,9 @@ export const config = {
     bot: {
         sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
+        serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
+        hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
+        hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
     },
     files: {
         maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),

package/dist/permission/manager.js

@@ -1,83 +1,99 @@
 import { logger } from "../utils/logger.js";
 class PermissionManager {
     state = {
-        request: null,
-        messageId: null,
-        isActive: false,
+        requestsByMessageId: new Map(),
     };
     /**
-     * Start a new permission request
+     * Register a new permission request message
      */
-    startPermission(request) {
-        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}`);
-        if (this.state.isActive) {
-            logger.warn("[PermissionManager] Permission already active, replacing");
-            this.clear();
+    startPermission(request, messageId) {
+        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}, messageId=${messageId}`);
+        if (this.state.requestsByMessageId.has(messageId)) {
+            logger.warn(`[PermissionManager] Message ID already tracked, replacing: ${messageId}`);
         }
-        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}`);
-        this.state = {
-            request,
-            messageId: null,
-            isActive: true,
-        };
-    }
-    /**
-     * Get current permission request
-     */
-    getRequest() {
-        return this.state.request;
+        this.state.requestsByMessageId.set(messageId, request);
+        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}, pending=${this.state.requestsByMessageId.size}`);
     }
     /**
-     * Get request ID for API reply
+     * Get permission request by Telegram message ID
      */
-    getRequestID() {
-        return this.state.request?.id ?? null;
+    getRequest(messageId) {
+        if (messageId === null) {
+            return null;
+        }
+        return this.state.requestsByMessageId.get(messageId) ?? null;
     }
     /**
-     * Get permission type (bash, edit, etc.)
+     * Get request ID for API reply by Telegram message ID
      */
-    getPermissionType() {
-        return this.state.request?.permission ?? null;
+    getRequestID(messageId) {
+        return this.getRequest(messageId)?.id ?? null;
     }
     /**
-     * Get patterns (commands/files)
+     * Get permission type (bash, edit, etc.) by message ID
      */
-    getPatterns() {
-        return this.state.request?.patterns ?? [];
+    getPermissionType(messageId) {
+        return this.getRequest(messageId)?.permission ?? null;
     }
     /**
-     * Set Telegram message ID for later deletion
+     * Get patterns (commands/files) by message ID
      */
-    setMessageId(messageId) {
-        this.state.messageId = messageId;
+    getPatterns(messageId) {
+        return this.getRequest(messageId)?.patterns ?? [];
     }
     /**
      * Check if callback message ID belongs to active permission request
      */
     isActiveMessage(messageId) {
-        return (this.state.isActive && this.state.messageId !== null && messageId === this.state.messageId);
+        return messageId !== null && this.state.requestsByMessageId.has(messageId);
     }
     /**
-     * Get Telegram message ID
+     * Get latest Telegram message ID
      */
     getMessageId() {
-        return this.state.messageId;
+        const messageIds = this.getMessageIds();
+        if (messageIds.length === 0) {
+            return null;
+        }
+        return messageIds[messageIds.length - 1];
+    }
+    /**
+     * Get Telegram message IDs for all active requests
+     */
+    getMessageIds() {
+        return Array.from(this.state.requestsByMessageId.keys());
+    }
+    /**
+     * Remove permission request by Telegram message ID
+     */
+    removeByMessageId(messageId) {
+        const request = this.getRequest(messageId);
+        if (!request || messageId === null) {
+            return null;
+        }
+        this.state.requestsByMessageId.delete(messageId);
+        logger.debug(`[PermissionManager] Removed permission request: id=${request.id}, messageId=${messageId}, pending=${this.state.requestsByMessageId.size}`);
+        return request;
+    }
+    /**
+     * Get number of active permission requests
+     */
+    getPendingCount() {
+        return this.state.requestsByMessageId.size;
     }
     /**
-     * Check if permission request is active
+     * Check if there are active permission requests
      */
     isActive() {
-        return this.state.isActive;
+        return this.state.requestsByMessageId.size > 0;
     }
     /**
      * Clear state after reply
      */
     clear() {
-        logger.debug("[PermissionManager] Clearing permission state");
+        logger.debug(`[PermissionManager] Clearing permission state: pending=${this.state.requestsByMessageId.size}`);
         this.state = {
-            request: null,
-            messageId: null,
-            isActive: false,
+            requestsByMessageId: new Map(),
         };
     }
 }

package/dist/pinned/manager.js

@@ -266,7 +266,7 @@ class PinnedMessageManager {
             logger.debug(`[PinnedManager] loadDiffsFromMessages: ${messagesData.length} messages`);
             const filesMap = new Map();
             let toolCount = 0;
-            let editWriteCount = 0;
+            let fileToolCount = 0;
             for (const { parts } of messagesData) {
                 for (const part of parts) {
                     if (part.type !== "tool")
@@ -275,10 +275,12 @@ class PinnedMessageManager {
                     const toolPart = part;
                     if (toolPart.state.status !== "completed")
                         continue;
-                    if (toolPart.tool === "edit" || toolPart.tool === "write") {
-                        editWriteCount++;
+                    if (toolPart.tool === "edit" ||
+                        toolPart.tool === "write" ||
+                        toolPart.tool === "apply_patch") {
+                        fileToolCount++;
                     }
-                    if (toolPart.tool === "edit" &&
+                    if ((toolPart.tool === "edit" || toolPart.tool === "apply_patch") &&
                         toolPart.state.metadata &&
                         "filediff" in toolPart.state.metadata) {
                         const filediff = toolPart.state.metadata.filediff;
@@ -318,7 +320,7 @@ class PinnedMessageManager {
                     }
                 }
             }
-            logger.debug(`[PinnedManager] loadDiffsFromMessages: found ${toolCount} tool parts, ${editWriteCount} edit/write`);
+            logger.debug(`[PinnedManager] loadDiffsFromMessages: found ${toolCount} tool parts, ${fileToolCount} file tools`);
             if (filesMap.size > 0) {
                 this.state.changedFiles = Array.from(filesMap.values());
                 logger.info(`[PinnedManager] Loaded ${this.state.changedFiles.length} file diffs from messages`);

package/dist/settings/manager.js

@@ -119,5 +119,10 @@ export function __resetSettingsForTests() {
     settingsWriteQueue = Promise.resolve();
 }
 export async function loadSettings() {
-    currentSettings = await readSettingsFile();
+    const loadedSettings = (await readSettingsFile());
+    if ("toolMessagesIntervalSec" in loadedSettings) {
+        delete loadedSettings.toolMessagesIntervalSec;
+        void writeSettingsFile(loadedSettings);
+    }
+    currentSettings = loadedSettings;
 }

package/dist/summary/aggregator.js

@@ -1,6 +1,29 @@
-import { prepareCodeFile } from "./formatter.js";
+import { normalizePathForDisplay, prepareCodeFile } from "./formatter.js";
 import { logger } from "../utils/logger.js";
 import { getCurrentProject } from "../settings/manager.js";
+function extractFirstUpdatedFileFromTitle(title) {
+    for (const rawLine of title.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length >= 3 && line[1] === " " && /[AMDURC]/.test(line[0])) {
+            return line.slice(2).trim();
+        }
+    }
+    return "";
+}
+function countDiffChangesFromText(text) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return { additions, deletions };
+}
 class SummaryAggregator {
     currentSessionId = null;
     currentMessageParts = new Map();
@@ -19,6 +42,7 @@ class SummaryAggregator {
     onPermissionCallback = null;
     onSessionDiffCallback = null;
     onFileChangeCallback = null;
+    onClearedCallback = null;
     processedToolStates = new Set();
     bot = null;
     chatId = null;
@@ -61,6 +85,9 @@ class SummaryAggregator {
     setOnFileChange(callback) {
         this.onFileChangeCallback = callback;
     }
+    setOnCleared(callback) {
+        this.onClearedCallback = callback;
+    }
     startTypingIndicator() {
         if (this.typingTimer) {
             return;
@@ -145,6 +172,14 @@ class SummaryAggregator {
         this.processedToolStates.clear();
         this.messageCount = 0;
         this.lastUpdated = 0;
+        if (this.onClearedCallback) {
+            try {
+                this.onClearedCallback();
+            }
+            catch (err) {
+                logger.error("[Aggregator] Error in clear callback:", err);
+            }
+        }
     }
     handleMessageUpdated(event) {
         const { info } = event.properties;
@@ -160,8 +195,11 @@ class SummaryAggregator {
                 this.startTypingIndicator();
                 // Notify that agent started thinking
                 if (this.onThinkingCallback) {
+                    const callback = this.onThinkingCallback;
                     setImmediate(() => {
-                        this.onThinkingCallback();
+                        if (typeof callback === "function") {
+                            callback(info.sessionID);
+                        }
                     });
                 }
             }
@@ -264,6 +302,7 @@ class SummaryAggregator {
                 if (!this.processedToolStates.has(notifiedKey)) {
                     this.processedToolStates.add(notifiedKey);
                     const toolData = {
+                        sessionId: part.sessionID,
                         messageId: messageID,
                         callId: part.callID,
                         tool: part.tool,
@@ -283,7 +322,8 @@ class SummaryAggregator {
                 if (!this.processedToolStates.has(fileKey)) {
                     this.processedToolStates.add(fileKey);
                     if (part.tool === "write" && input && "content" in input && "filePath" in input) {
-                        const fileData = prepareCodeFile(input.content, input.filePath, "write");
+                        const filePath = normalizePathForDisplay(input.filePath);
+                        const fileData = prepareCodeFile(input.content, filePath, "write");
                         if (fileData && this.onToolFileCallback) {
                             logger.debug(`[Aggregator] Sending write file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
                             this.onToolFileCallback(fileData);
@@ -292,7 +332,7 @@ class SummaryAggregator {
                         if (this.onFileChangeCallback) {
                             const lines = input.content.split("\n").length;
                             this.onFileChangeCallback({
-                                file: input.filePath,
+                                file: filePath,
                                 additions: lines,
                                 deletions: 0,
                             });
@@ -303,12 +343,12 @@ class SummaryAggregator {
                         "diff" in state.metadata &&
                         "filediff" in state.metadata) {
                         const filediff = state.metadata.filediff;
-                        const filePath = filediff.file;
+                        const filePath = filediff.file ? normalizePathForDisplay(filediff.file) : undefined;
                         const diff = state.metadata.diff;
                         if (filePath && diff) {
                             const fileData = prepareCodeFile(diff, filePath, "edit");
                             if (fileData && this.onToolFileCallback) {
-                                logger.debug(`[Aggregator] Sending edit file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                                logger.debug(`[Aggregator] Sending ${part.tool} file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
                                 this.onToolFileCallback(fileData);
                             }
                             // Notify about file change for pinned message
@@ -321,6 +361,47 @@ class SummaryAggregator {
                             }
                         }
                     }
+                    else if (part.tool === "apply_patch") {
+                        const metadata = state.metadata;
+                        const filePathFromInput = input && typeof input.filePath === "string"
+                            ? normalizePathForDisplay(input.filePath)
+                            : input && typeof input.path === "string"
+                                ? normalizePathForDisplay(input.path)
+                                : "";
+                        const filePathFromTitle = title ? extractFirstUpdatedFileFromTitle(title) : "";
+                        const filePath = (metadata?.filediff?.file && normalizePathForDisplay(metadata.filediff.file)) ||
+                            filePathFromInput ||
+                            normalizePathForDisplay(filePathFromTitle);
+                        const diffText = typeof metadata?.diff === "string"
+                            ? metadata.diff
+                            : input && typeof input.patchText === "string"
+                                ? input.patchText
+                                : "";
+                        if (filePath && diffText) {
+                            const fileData = prepareCodeFile(diffText, filePath, "edit");
+                            if (fileData && this.onToolFileCallback) {
+                                logger.debug(`[Aggregator] Sending apply_patch file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                                this.onToolFileCallback(fileData);
+                            }
+                        }
+                        if (filePath && this.onFileChangeCallback) {
+                            if (metadata?.filediff) {
+                                this.onFileChangeCallback({
+                                    file: filePath,
+                                    additions: metadata.filediff.additions || 0,
+                                    deletions: metadata.filediff.deletions || 0,
+                                });
+                            }
+                            else if (diffText) {
+                                const changes = countDiffChangesFromText(diffText);
+                                this.onFileChangeCallback({
+                                    file: filePath,
+                                    additions: changes.additions,
+                                    deletions: changes.deletions,
+                                });
+                            }
+                        }
+                    }
                 }
             }
         }

package/dist/summary/formatter.js

@@ -2,6 +2,7 @@ import * as path from "path";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
+import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 function splitText(text, maxLength) {
     const parts = [];
@@ -21,6 +22,27 @@ function splitText(text, maxLength) {
     }
     return parts;
 }
+export function normalizePathForDisplay(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const project = getCurrentProject();
+    if (!project?.worktree) {
+        return normalizedPath;
+    }
+    const normalizedWorktree = project.worktree.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (!normalizedWorktree) {
+        return normalizedPath;
+    }
+    const pathForCompare = process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+    const worktreeForCompare = process.platform === "win32" ? normalizedWorktree.toLowerCase() : normalizedWorktree;
+    if (pathForCompare === worktreeForCompare) {
+        return ".";
+    }
+    const worktreePrefix = `${worktreeForCompare}/`;
+    if (pathForCompare.startsWith(worktreePrefix)) {
+        return normalizedPath.slice(normalizedWorktree.length + 1);
+    }
+    return normalizedPath;
+}
 export function formatSummary(text) {
     if (!text || text.trim().length === 0) {
         return [];
@@ -50,9 +72,10 @@ function getToolDetails(tool, input) {
         case "read":
         case "edit":
         case "write":
-            const path = input.path || input.filePath;
-            if (typeof path === "string")
-                return path;
+        case "apply_patch":
+            const filePath = input.path || input.filePath;
+            if (typeof filePath === "string")
+                return normalizePathForDisplay(filePath);
             break;
         case "bash":
             if (typeof input.command === "string")
@@ -88,6 +111,8 @@ function getToolIcon(tool) {
             return "✍️";
         case "edit":
             return "✏️";
+        case "apply_patch":
+            return "🩹";
         case "bash":
             return "💻";
         case "glob":
@@ -133,6 +158,37 @@ function formatTodos(todos) {
     }
     return result;
 }
+function formatDiffLineInfo(filediff) {
+    const parts = [];
+    if (filediff.additions && filediff.additions > 0)
+        parts.push(`+${filediff.additions}`);
+    if (filediff.deletions && filediff.deletions > 0)
+        parts.push(`-${filediff.deletions}`);
+    return parts.length > 0 ? ` (${parts.join(" ")})` : "";
+}
+function countDiffChangesFromText(text) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return { additions, deletions };
+}
+function extractFirstUpdatedFileFromTitle(title) {
+    for (const rawLine of title.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length >= 3 && line[1] === " " && /[AMDURC]/.test(line[0])) {
+            return line.slice(2).trim();
+        }
+    }
+    return "";
+}
 export function formatToolInfo(toolInfo) {
     const { tool, input, title } = toolInfo;
     logger.debug(`[Formatter] formatToolInfo: tool=${tool}, hasMetadata=${!!toolInfo.metadata}, hasFilediff=${!!toolInfo.metadata?.filediff}`);
@@ -151,22 +207,41 @@ export function formatToolInfo(toolInfo) {
     if (tool === "bash" && input && typeof input.command === "string") {
         details = input.command;
     }
+    if (tool === "apply_patch") {
+        const filediff = toolInfo.metadata && "filediff" in toolInfo.metadata
+            ? toolInfo.metadata.filediff
+            : undefined;
+        if (filediff?.file) {
+            details = normalizePathForDisplay(filediff.file);
+        }
+        else if (title) {
+            const fileFromTitle = extractFirstUpdatedFileFromTitle(title);
+            if (fileFromTitle) {
+                details = normalizePathForDisplay(fileFromTitle);
+            }
+        }
+    }
     const detailsStr = details ? ` ${details}` : "";
     let lineInfo = "";
     if (tool === "write" && input && "content" in input && typeof input.content === "string") {
         const lines = countLines(input.content);
         lineInfo = ` (+${lines})`;
     }
-    if (tool === "edit" && toolInfo.metadata && "filediff" in toolInfo.metadata) {
+    if ((tool === "edit" || tool === "apply_patch") &&
+        toolInfo.metadata &&
+        "filediff" in toolInfo.metadata) {
         const filediff = toolInfo.metadata.filediff;
-        logger.debug("[Formatter] Edit metadata:", JSON.stringify(toolInfo.metadata, null, 2));
-        const parts = [];
-        if (filediff.additions && filediff.additions > 0)
-            parts.push(`+${filediff.additions}`);
-        if (filediff.deletions && filediff.deletions > 0)
-            parts.push(`-${filediff.deletions}`);
-        if (parts.length > 0) {
-            lineInfo = ` (${parts.join(" ")})`;
+        logger.debug("[Formatter] Diff metadata:", JSON.stringify(toolInfo.metadata, null, 2));
+        lineInfo = formatDiffLineInfo(filediff);
+    }
+    if (tool === "apply_patch" && !lineInfo) {
+        const diffText = toolInfo.metadata && typeof toolInfo.metadata.diff === "string"
+            ? toolInfo.metadata.diff
+            : input && typeof input.patchText === "string"
+                ? input.patchText
+                : "";
+        if (diffText) {
+            lineInfo = formatDiffLineInfo(countDiffChangesFromText(diffText));
         }
     }
     return `${toolIcon} ${description}${tool}${detailsStr}${lineInfo}`;
@@ -209,18 +284,19 @@ function formatDiff(diff) {
     return formattedLines.join("\n");
 }
 export function prepareCodeFile(content, filePath, operation) {
+    const displayPath = normalizePathForDisplay(filePath);
     let processedContent = content;
     if (operation === "edit") {
         processedContent = formatDiff(content);
     }
     const sizeKb = Buffer.byteLength(processedContent, "utf8") / 1024;
     if (sizeKb > config.files.maxFileSizeKb) {
-        logger.debug(`[Formatter] File too large: ${filePath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
+        logger.debug(`[Formatter] File too large: ${displayPath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
         return null;
     }
     const header = operation === "write"
-        ? t("tool.file_header.write", { path: filePath })
-        : t("tool.file_header.edit", { path: filePath });
+        ? t("tool.file_header.write", { path: displayPath })
+        : t("tool.file_header.edit", { path: displayPath });
     const fullContent = header + processedContent;
     const buffer = Buffer.from(fullContent, "utf8");
     const basename = path.basename(filePath);

package/dist/summary/tool-message-batcher.js

@@ -0,0 +1,182 @@
+import { logger } from "../utils/logger.js";
+const DEFAULT_INTERVAL_SECONDS = 5;
+const TELEGRAM_MESSAGE_MAX_LENGTH = 4096;
+function normalizeIntervalSeconds(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    const normalized = Math.floor(value);
+    if (normalized < 0) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    return normalized;
+}
+export class ToolMessageBatcher {
+    intervalSeconds;
+    sendMessage;
+    queues = new Map();
+    timers = new Map();
+    generation = 0;
+    constructor(options) {
+        this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
+        this.sendMessage = options.sendMessage;
+    }
+    setIntervalSeconds(nextIntervalSeconds) {
+        const normalized = normalizeIntervalSeconds(nextIntervalSeconds);
+        if (this.intervalSeconds === normalized) {
+            return;
+        }
+        this.intervalSeconds = normalized;
+        logger.info(`[ToolBatcher] Interval updated: ${normalized}s`);
+        if (normalized === 0) {
+            void this.flushAll("interval_updated");
+            return;
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            this.restartTimer(sessionId);
+        }
+    }
+    getIntervalSeconds() {
+        return this.intervalSeconds;
+    }
+    enqueue(sessionId, message) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            logger.debug(`[ToolBatcher] Sending immediate message: session=${sessionId}`);
+            void this.sendMessageSafe(sessionId, normalizedMessage, "immediate", expectedGeneration);
+            return;
+        }
+        const queue = this.queues.get(sessionId) ?? [];
+        queue.push(normalizedMessage);
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    async flushSession(sessionId, reason) {
+        const expectedGeneration = this.generation;
+        this.clearTimer(sessionId);
+        const queuedMessages = this.queues.get(sessionId);
+        if (!queuedMessages || queuedMessages.length === 0) {
+            return;
+        }
+        this.queues.delete(sessionId);
+        const batches = this.packMessages(queuedMessages);
+        logger.debug(`[ToolBatcher] Flushing ${queuedMessages.length} tool messages as ${batches.length} Telegram messages (session=${sessionId}, reason=${reason})`);
+        for (const batchMessage of batches) {
+            await this.sendMessageSafe(sessionId, batchMessage, reason, expectedGeneration);
+        }
+    }
+    async flushAll(reason) {
+        for (const sessionId of Array.from(this.timers.keys())) {
+            this.clearTimer(sessionId);
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            await this.flushSession(sessionId, reason);
+        }
+    }
+    clearSession(sessionId, reason) {
+        this.generation++;
+        this.clearTimer(sessionId);
+        if (this.queues.delete(sessionId)) {
+            logger.debug(`[ToolBatcher] Cleared session queue: session=${sessionId}, reason=${reason}`);
+        }
+    }
+    clearAll(reason) {
+        this.generation++;
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        const queuedSessions = this.queues.size;
+        this.timers.clear();
+        this.queues.clear();
+        if (queuedSessions > 0) {
+            logger.debug(`[ToolBatcher] Cleared all queued tool messages: sessions=${queuedSessions}, reason=${reason}`);
+        }
+    }
+    clearTimer(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    ensureTimer(sessionId) {
+        if (this.timers.has(sessionId)) {
+            return;
+        }
+        this.restartTimer(sessionId);
+    }
+    restartTimer(sessionId) {
+        this.clearTimer(sessionId);
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.flushSession(sessionId, "interval_elapsed");
+        }, this.intervalSeconds * 1000);
+        this.timers.set(sessionId, timer);
+    }
+    async sendMessageSafe(sessionId, text, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool batch message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendMessage(sessionId, text);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool batch message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    packMessages(messages) {
+        const normalizedEntries = messages
+            .flatMap((message) => this.splitLongText(message, TELEGRAM_MESSAGE_MAX_LENGTH))
+            .filter((entry) => entry.length > 0);
+        if (normalizedEntries.length === 0) {
+            return [];
+        }
+        const result = [];
+        let current = "";
+        for (const entry of normalizedEntries) {
+            if (!current) {
+                current = entry;
+                continue;
+            }
+            const candidate = `${current}\n\n${entry}`;
+            if (candidate.length <= TELEGRAM_MESSAGE_MAX_LENGTH) {
+                current = candidate;
+                continue;
+            }
+            result.push(current);
+            current = entry;
+        }
+        if (current) {
+            result.push(current);
+        }
+        return result;
+    }
+    splitLongText(text, limit) {
+        if (text.length <= limit) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > limit) {
+            let splitIndex = remaining.lastIndexOf("\n", limit);
+            if (splitIndex <= 0 || splitIndex < Math.floor(limit * 0.5)) {
+                splitIndex = limit;
+            }
+            chunks.push(remaining.slice(0, splitIndex));
+            remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
+        }
+        if (remaining.length > 0) {
+            chunks.push(remaining);
+        }
+        return chunks;
+    }
+}

package/package.json

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