@grinev/opencode-telegram-bot 0.13.1 → 0.14.0

package/.env.example

@@ -50,20 +50,12 @@ OPENCODE_MODEL_ID=big-pickle
 # Supported locales: en, de, es, fr, ru, zh
 # BOT_LOCALE=en
 
-# Service message batching interval in seconds (thinking + tool calls, default: 5)
-# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
-# 0 = send immediately (can hit rate limits if there are many tool calls)
-# SERVICE_MESSAGES_INTERVAL_SEC=5
-
 # Hide thinking indicator messages (default: false)
 # HIDE_THINKING_MESSAGES=false
 
 # Hide tool call service messages (default: false)
 # HIDE_TOOL_CALL_MESSAGES=false
 
-# Stream assistant responses while they are being generated (default: true)
-# RESPONSE_STREAMING=true
-
 # Assistant message formatting mode (default: markdown)
 # markdown = convert assistant replies to Telegram MarkdownV2
 # raw = show assistant replies as plain text

package/README.md

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

package/dist/bot/commands/sessions.js

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

package/dist/bot/index.js

@@ -37,6 +37,7 @@ import { keyboardManager } from "../keyboard/manager.js";
 import { subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatSummaryWithMode, formatToolInfo, getAssistantParseMode, } from "../summary/formatter.js";
+import { renderSubagentCards } from "../summary/subagent-formatter.js";
 import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { getCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
@@ -56,6 +57,7 @@ import { getStoredModel } from "../model/manager.js";
 import { foregroundSessionState } from "../scheduled-task/foreground-state.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { ResponseStreamer } from "./streaming/response-streamer.js";
+import { ToolCallStreamer } from "./streaming/tool-call-streamer.js";
 import { editMessageWithMarkdownFallback, sendMessageWithMarkdownFallback, } from "./utils/send-with-markdown-fallback.js";
 let botInstance = null;
 let chatIdInstance = null;
@@ -64,6 +66,7 @@ const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = 200;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
 const SESSION_RETRY_PREFIX = "🔁";
+const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
@@ -94,7 +97,6 @@ function prepareStreamingPayload(messageText) {
     };
 }
 const toolMessageBatcher = new ToolMessageBatcher({
-    intervalSeconds: 5,
     sendText: async (sessionId, text) => {
         if (!botInstance || !chatIdInstance) {
             return;
@@ -187,6 +189,58 @@ const responseStreamer = new ResponseStreamer({
         });
     },
 });
+const toolCallStreamer = new ToolCallStreamer({
+    throttleMs: RESPONSE_STREAM_THROTTLE_MS,
+    sendText: async (sessionId, text) => {
+        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+            throw new Error("Bot context missing for tool stream send");
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            throw new Error(`Tool stream session mismatch for send: ${sessionId}`);
+        }
+        const sentMessage = await botInstance.api.sendMessage(chatIdInstance, text, {
+            disable_notification: true,
+        });
+        return sentMessage.message_id;
+    },
+    editText: async (sessionId, messageId, text) => {
+        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+            throw new Error("Bot context missing for tool stream edit");
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            throw new Error(`Tool stream session mismatch for edit: ${sessionId}`);
+        }
+        try {
+            await botInstance.api.editMessageText(chatIdInstance, messageId, text);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+            if (errorMessage.includes("message is not modified")) {
+                return;
+            }
+            throw error;
+        }
+    },
+    deleteText: async (sessionId, messageId) => {
+        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+            throw new Error("Bot context missing for tool stream delete");
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            throw new Error(`Tool stream session mismatch for delete: ${sessionId}`);
+        }
+        await botInstance.api.deleteMessage(chatIdInstance, messageId).catch((error) => {
+            const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+            if (errorMessage.includes("message to delete not found") ||
+                errorMessage.includes("message identifier is not specified")) {
+                return;
+            }
+            throw error;
+        });
+    },
+});
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -217,16 +271,13 @@ async function ensureEventSubscription(directory) {
         logger.error("No directory found for event subscription");
         return;
     }
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
     summaryAggregator.setTypingIndicatorEnabled(true);
     summaryAggregator.setOnCleared(() => {
         toolMessageBatcher.clearAll("summary_aggregator_clear");
+        toolCallStreamer.clearAll("summary_aggregator_clear");
         responseStreamer.clearAll("summary_aggregator_clear");
     });
     summaryAggregator.setOnPartial((sessionId, messageId, messageText) => {
-        if (!config.bot.responseStreaming) {
-            return;
-        }
         if (!botInstance || !chatIdInstance) {
             return;
         }
@@ -238,7 +289,7 @@ async function ensureEventSubscription(directory) {
         if (!preparedStreamPayload) {
             return;
         }
-        preparedStreamPayload.sendOptions = undefined;
+        preparedStreamPayload.sendOptions = { disable_notification: true };
         preparedStreamPayload.editOptions = undefined;
         responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
     });
@@ -246,12 +297,14 @@ async function ensureEventSubscription(directory) {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending message");
             responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
+            toolCallStreamer.clearSession(sessionId, "bot_context_missing");
             foregroundSessionState.markIdle(sessionId);
             return;
         }
         const currentSession = getCurrentSession();
         if (currentSession?.id !== sessionId) {
             responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
+            toolCallStreamer.clearSession(sessionId, "session_mismatch");
             foregroundSessionState.markIdle(sessionId);
             await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
@@ -259,13 +312,15 @@ async function ensureEventSubscription(directory) {
         const botApi = botInstance.api;
         const chatId = chatIdInstance;
         try {
-            const streamedViaMessages = await finalizeAssistantResponse({
-                responseStreaming: config.bot.responseStreaming,
+            await finalizeAssistantResponse({
                 sessionId,
                 messageId,
                 messageText,
                 responseStreamer,
-                flushPendingServiceMessages: () => toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
+                flushPendingServiceMessages: () => Promise.all([
+                    toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
+                    toolCallStreamer.flushSession(sessionId, "assistant_message_completed"),
+                ]).then(() => undefined),
                 prepareStreamingPayload,
                 formatSummary,
                 resolveFormat: () => (getAssistantParseMode() === "MarkdownV2" ? "markdown_v2" : "raw"),
@@ -279,13 +334,17 @@ async function ensureEventSubscription(directory) {
                         format,
                     });
                 },
+                deleteMessages: async (messageIds) => {
+                    for (const msgId of messageIds) {
+                        try {
+                            await botApi.deleteMessage(chatId, msgId);
+                        }
+                        catch (err) {
+                            logger.warn(`[Bot] Failed to delete streamed message ${msgId}:`, err);
+                        }
+                    }
+                },
             });
-            if (streamedViaMessages) {
-                logger.debug(`[Bot] Final assistant message already streamed (session=${sessionId}, message=${messageId})`);
-                foregroundSessionState.markIdle(sessionId);
-                await scheduledTaskRuntime.flushDeferredDeliveries();
-                return;
-            }
         }
         catch (err) {
             logger.error("Failed to send message to Telegram:", err);
@@ -309,19 +368,43 @@ async function ensureEventSubscription(directory) {
         }
         const shouldIncludeToolInfoInFileCaption = toolInfo.hasFileAttachment &&
             (toolInfo.tool === "write" || toolInfo.tool === "edit" || toolInfo.tool === "apply_patch");
-        if (config.bot.hideToolCallMessages || shouldIncludeToolInfoInFileCaption) {
+        if (config.bot.hideToolCallMessages ||
+            shouldIncludeToolInfoInFileCaption ||
+            toolInfo.tool === "task") {
             return;
         }
         try {
             const message = formatToolInfo(toolInfo);
             if (message) {
-                toolMessageBatcher.enqueue(toolInfo.sessionId, message);
+                toolCallStreamer.append(toolInfo.sessionId, message);
             }
         }
         catch (err) {
             logger.error("Failed to send tool notification to Telegram:", err);
         }
     });
+    summaryAggregator.setOnSubagent(async (sessionId, subagents) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        if (config.bot.hideToolCallMessages) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        try {
+            const renderedCards = await renderSubagentCards(subagents);
+            if (!renderedCards) {
+                return;
+            }
+            toolCallStreamer.replaceByPrefix(sessionId, SUBAGENT_STREAM_PREFIX, renderedCards);
+        }
+        catch (err) {
+            logger.error("Failed to render subagent activity for Telegram:", err);
+        }
+    });
     summaryAggregator.setOnToolFile(async (fileInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending file");
@@ -332,6 +415,7 @@ async function ensureEventSubscription(directory) {
             return;
         }
         try {
+            await toolCallStreamer.breakSession(fileInfo.sessionId, "tool_file_boundary");
             const toolMessage = formatToolInfo(fileInfo);
             const caption = prepareDocumentCaption(toolMessage || fileInfo.fileData.caption);
             toolMessageBatcher.enqueueFile(fileInfo.sessionId, {
@@ -350,7 +434,10 @@ async function ensureEventSubscription(directory) {
         }
         const currentSession = getCurrentSession();
         if (currentSession) {
-            await toolMessageBatcher.flushSession(currentSession.id, "question_asked");
+            await Promise.all([
+                toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
+                toolCallStreamer.flushSession(currentSession.id, "question_asked"),
+            ]);
         }
         if (questionManager.isActive()) {
             logger.warn("[Bot] Replacing active poll with a new one");
@@ -382,7 +469,10 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing permission request");
             return;
         }
-        await toolMessageBatcher.flushSession(request.sessionID, "permission_asked");
+        await Promise.all([
+            toolMessageBatcher.flushSession(request.sessionID, "permission_asked"),
+            toolCallStreamer.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);
     });
@@ -395,25 +485,40 @@ async function ensureEventSubscription(directory) {
             return;
         }
         logger.debug("[Bot] Agent started thinking");
+        await toolCallStreamer.breakSession(sessionId, "thinking_started");
         deliverThinkingMessage(sessionId, toolMessageBatcher, {
-            responseStreaming: config.bot.responseStreaming,
             hideThinkingMessages: config.bot.hideThinkingMessages,
         });
+        // Refresh pinned message so it shows the latest in-memory context
+        // (accumulated from silent token updates). 1 API call per thinking event.
+        if (pinnedMessageManager.isInitialized()) {
+            await pinnedMessageManager.refresh();
+        }
     });
-    summaryAggregator.setOnTokens(async (tokens) => {
+    summaryAggregator.setOnTokens(async (tokens, isCompleted) => {
         if (!pinnedMessageManager.isInitialized()) {
             return;
         }
         try {
-            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}`);
-            // Update keyboardManager SYNCHRONOUSLY before any await
-            // This ensures keyboard has correct context when onComplete sends the reply
+            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}, completed=${isCompleted}`);
             const contextSize = tokens.input + tokens.cacheRead;
             const contextLimit = pinnedMessageManager.getContextLimit();
+            // Skip non-completed messages with zero context: a new assistant message
+            // starts with tokens={input:0, ...} which would overwrite valid context
+            // from the previous step. Only accept zeros from completed messages.
+            if (!isCompleted && contextSize === 0) {
+                logger.debug("[Bot] Skipping zero-token intermediate update");
+                return;
+            }
+            // Update both keyboard and pinned state in memory (keeps them in sync)
             if (contextLimit > 0) {
                 keyboardManager.updateContext(contextSize, contextLimit);
             }
-            await pinnedMessageManager.onMessageComplete(tokens);
+            pinnedMessageManager.updateTokensSilent(tokens);
+            // Full pinned message update (API call) only on completed messages
+            if (isCompleted) {
+                await pinnedMessageManager.onMessageComplete(tokens);
+            }
         }
         catch (err) {
             logger.error("[Bot] Error updating pinned message with tokens:", err);
@@ -451,12 +556,16 @@ async function ensureEventSubscription(directory) {
         const currentSession = getCurrentSession();
         if (!currentSession || currentSession.id !== sessionId) {
             responseStreamer.clearSession(sessionId, "session_error_not_current");
+            toolCallStreamer.clearSession(sessionId, "session_error_not_current");
             foregroundSessionState.markIdle(sessionId);
             await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
         }
         responseStreamer.clearSession(sessionId, "session_error");
-        await toolMessageBatcher.flushSession(sessionId, "session_error");
+        await Promise.all([
+            toolMessageBatcher.flushSession(sessionId, "session_error"),
+            toolCallStreamer.flushSession(sessionId, "session_error"),
+        ]);
         const normalizedMessage = message.trim() || t("common.unknown_error");
         const truncatedMessage = normalizedMessage.length > 3500
             ? `${normalizedMessage.slice(0, 3497)}...`
@@ -482,7 +591,7 @@ async function ensureEventSubscription(directory) {
             ? `${normalizedMessage.slice(0, 3497)}...`
             : normalizedMessage;
         const retryMessage = t("bot.session_retry", { message: truncatedMessage });
-        toolMessageBatcher.enqueueUniqueByPrefix(sessionId, retryMessage, SESSION_RETRY_PREFIX);
+        toolCallStreamer.replaceByPrefix(sessionId, SESSION_RETRY_PREFIX, retryMessage);
     });
     summaryAggregator.setOnSessionDiff(async (_sessionId, diffs) => {
         if (!pinnedMessageManager.isInitialized()) {
@@ -529,8 +638,6 @@ async function ensureEventSubscription(directory) {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
-    logger.debug(`[ToolBatcher] Service messages interval: ${config.bot.serviceMessagesIntervalSec}s`);
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;

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

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