@grinev/opencode-telegram-bot 0.15.0 → 0.16.0

package/dist/bot/handlers/prompt.js

@@ -17,6 +17,7 @@ import { formatErrorDetails } from "../../utils/error-format.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { assistantRunState } from "../assistant-run-state.js";
 /** Module-level references for async callbacks that don't have ctx. */
 let botInstance = null;
 let chatIdInstance = null;
@@ -61,6 +62,7 @@ async function resetMismatchedSessionContext() {
     stopEventListening();
     summaryAggregator.clear();
     foregroundSessionState.clearAll("session_mismatch_reset");
+    assistantRunState.clearAll("session_mismatch_reset");
     clearAllInteractionState("session_mismatch_reset");
     clearSession();
     keyboardManager.clearContext();
@@ -209,6 +211,12 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         foregroundSessionState.markBusy(currentSession.id);
+        assistantRunState.startRun(currentSession.id, {
+            startedAt: Date.now(),
+            configuredAgent: currentAgent,
+            configuredProviderID: storedModel.providerID,
+            configuredModelID: storedModel.modelID,
+        });
         setPromptResponseMode(currentSession.id, responseMode);
         // CRITICAL: DO NOT wait for session.prompt to complete.
         // If we wait, the handler will not finish and grammY will not call getUpdates,
@@ -220,6 +228,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             onSuccess: ({ error }) => {
                 if (error) {
                     foregroundSessionState.markIdle(currentSession.id);
+                    assistantRunState.clearRun(currentSession.id, "session_prompt_api_error");
                     clearPromptResponseMode(currentSession.id);
                     const details = formatErrorDetails(error, 6000);
                     logger.error("[Bot] OpenCode API returned an error for session.prompt", promptErrorLogContext);
@@ -233,6 +242,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             },
             onError: (error) => {
                 foregroundSessionState.markIdle(currentSession.id);
+                assistantRunState.clearRun(currentSession.id, "session_prompt_background_error");
                 clearPromptResponseMode(currentSession.id);
                 const details = formatErrorDetails(error, 6000);
                 logger.error("[Bot] session.prompt background task failed", promptErrorLogContext);
@@ -246,6 +256,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     catch (err) {
         if (currentSession) {
             foregroundSessionState.markIdle(currentSession.id);
+            assistantRunState.clearRun(currentSession.id, "session_prompt_handler_error");
         }
         logger.error("Error in prompt handler:", err);
         if (interactionManager.getSnapshot()) {

package/dist/bot/index.js

@@ -16,6 +16,7 @@ import { AGENT_MODE_BUTTON_TEXT_PATTERN, MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTT
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
+import { openCommand, handleOpenCallback, clearOpenPathIndex } from "./commands/open.js";
 import { abortCommand } from "./commands/abort.js";
 import { opencodeStartCommand } from "./commands/opencode-start.js";
 import { opencodeStopCommand } from "./commands/opencode-stop.js";
@@ -37,7 +38,7 @@ import { clearAllInteractionState } from "../interaction/cleanup.js";
 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 { formatToolInfo } 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";
@@ -54,14 +55,16 @@ import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
 import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
-import { sendBotText } from "./utils/telegram-text.js";
+import { editRenderedBotPart, getTelegramRenderedPartSignature, sendRenderedBotPart, } from "./utils/telegram-text.js";
+import { formatAssistantRunFooter } from "./utils/assistant-run-footer.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
 import { getStoredModel } from "../model/manager.js";
 import { foregroundSessionState } from "../scheduled-task/foreground-state.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
+import { assistantRunState } from "./assistant-run-state.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";
+import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload, renderAssistantFinalPartsSafe, } from "./utils/assistant-rendering.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
@@ -73,6 +76,7 @@ const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
+const sessionCompletionTasks = new Map();
 function getCurrentReplyKeyboard() {
     if (!keyboardManager.isInitialized()) {
         return undefined;
@@ -90,14 +94,23 @@ function prepareDocumentCaption(caption) {
     return `${normalizedCaption.slice(0, TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH - 3)}...`;
 }
 function prepareStreamingPayload(messageText) {
-    const parts = formatSummaryWithMode(messageText, config.bot.messageFormatMode, RESPONSE_STREAM_TEXT_LIMIT);
-    if (parts.length === 0) {
-        return null;
-    }
-    return {
-        parts,
-        format: "raw",
-    };
+    return prepareAssistantStreamingPayload(messageText, RESPONSE_STREAM_TEXT_LIMIT);
+}
+function prepareFinalStreamingPayload(messageText) {
+    return prepareAssistantFinalStreamingPayload(messageText, RESPONSE_STREAM_TEXT_LIMIT);
+}
+function enqueueSessionCompletionTask(sessionId, task) {
+    const previousTask = sessionCompletionTasks.get(sessionId) ?? Promise.resolve();
+    const nextTask = previousTask
+        .catch(() => undefined)
+        .then(task)
+        .finally(() => {
+        if (sessionCompletionTasks.get(sessionId) === nextTask) {
+            sessionCompletionTasks.delete(sessionId);
+        }
+    });
+    sessionCompletionTasks.set(sessionId, nextTask);
+    return nextTask;
 }
 const toolMessageBatcher = new ToolMessageBatcher({
     sendText: async (sessionId, text) => {
@@ -141,39 +154,36 @@ const toolMessageBatcher = new ToolMessageBatcher({
 });
 const responseStreamer = new ResponseStreamer({
     throttleMs: RESPONSE_STREAM_THROTTLE_MS,
-    sendText: async (text, format, options) => {
+    sendPart: async (part, options) => {
         if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
             throw new Error("Bot context missing for streamed send");
         }
-        const parseMode = format === "markdown_v2" ? "MarkdownV2" : undefined;
-        const sentMessage = await sendMessageWithMarkdownFallback({
+        return sendRenderedBotPart({
             api: botInstance.api,
             chatId: chatIdInstance,
-            text,
+            part,
             options,
-            parseMode,
         });
-        return sentMessage.message_id;
     },
-    editText: async (messageId, text, format, options) => {
+    editPart: async (messageId, part, options) => {
         if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
             throw new Error("Bot context missing for streamed edit");
         }
-        const parseMode = format === "markdown_v2" ? "MarkdownV2" : undefined;
         try {
-            await editMessageWithMarkdownFallback({
+            return await editRenderedBotPart({
                 api: botInstance.api,
                 chatId: chatIdInstance,
                 messageId,
-                text,
+                part,
                 options,
-                parseMode,
             });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
             if (errorMessage.includes("message is not modified")) {
-                return;
+                return {
+                    deliveredSignature: getTelegramRenderedPartSignature(part),
+                };
             }
             throw error;
         }
@@ -298,84 +308,82 @@ async function ensureEventSubscription(directory) {
         if (!preparedStreamPayload) {
             return;
         }
+        // Reply keyboards make the first streamed message non-editable in Telegram,
+        // so partial chunks must be sent without reply_markup and finalized later.
         preparedStreamPayload.sendOptions = { disable_notification: true };
         preparedStreamPayload.editOptions = undefined;
         responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
     });
-    summaryAggregator.setOnComplete(async (sessionId, messageId, messageText) => {
-        if (!botInstance || !chatIdInstance) {
-            logger.error("Bot or chat ID not available for sending message");
-            clearPromptResponseMode(sessionId);
-            responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
-            toolCallStreamer.clearSession(sessionId, "bot_context_missing");
-            foregroundSessionState.markIdle(sessionId);
-            return;
-        }
-        const currentSession = getCurrentSession();
-        if (currentSession?.id !== sessionId) {
-            clearPromptResponseMode(sessionId);
-            responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
-            toolCallStreamer.clearSession(sessionId, "session_mismatch");
-            foregroundSessionState.markIdle(sessionId);
-            await scheduledTaskRuntime.flushDeferredDeliveries();
-            return;
-        }
-        const botApi = botInstance.api;
-        const chatId = chatIdInstance;
-        try {
-            await finalizeAssistantResponse({
-                sessionId,
-                messageId,
-                messageText,
-                responseStreamer,
-                flushPendingServiceMessages: () => Promise.all([
-                    toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
-                    toolCallStreamer.flushSession(sessionId, "assistant_message_completed"),
-                ]).then(() => undefined),
-                prepareStreamingPayload,
-                formatSummary,
-                formatRawSummary: (text) => formatSummaryWithMode(text, "raw"),
-                resolveFormat: () => (getAssistantParseMode() === "MarkdownV2" ? "markdown_v2" : "raw"),
-                getReplyKeyboard: getCurrentReplyKeyboard,
-                sendText: async (text, rawFallbackText, options, format) => {
-                    await sendBotText({
-                        api: botApi,
-                        chatId,
-                        text,
-                        rawFallbackText,
-                        options: options,
-                        format,
-                    });
-                },
-                deleteMessages: async (messageIds) => {
-                    for (const msgId of messageIds) {
-                        try {
-                            await botApi.deleteMessage(chatId, msgId);
-                        }
-                        catch (err) {
-                            logger.warn(`[Bot] Failed to delete streamed message ${msgId}:`, err);
-                        }
-                    }
-                },
-            });
-            await sendTtsResponseForSession({
-                api: botApi,
-                sessionId,
-                chatId,
-                text: messageText,
-            });
-        }
-        catch (err) {
-            clearPromptResponseMode(sessionId);
-            logger.error("Failed to send message to Telegram:", err);
-            // Stop processing events after critical error to prevent infinite loop
-            logger.error("[Bot] CRITICAL: Stopping event processing due to error");
-            summaryAggregator.clear();
-        }
-        finally {
-            foregroundSessionState.markIdle(sessionId);
-            await scheduledTaskRuntime.flushDeferredDeliveries();
-        }
+    summaryAggregator.setOnComplete((sessionId, messageId, messageText, completionInfo) => {
+        void enqueueSessionCompletionTask(sessionId, async () => {
+            if (!botInstance || !chatIdInstance) {
+                logger.error("Bot or chat ID not available for sending message");
+                clearPromptResponseMode(sessionId);
+                responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
+                toolCallStreamer.clearSession(sessionId, "bot_context_missing");
+                assistantRunState.clearRun(sessionId, "bot_context_missing");
+                foregroundSessionState.markIdle(sessionId);
+                return;
+            }
+            const currentSession = getCurrentSession();
+            if (currentSession?.id !== sessionId) {
+                clearPromptResponseMode(sessionId);
+                responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
+                toolCallStreamer.clearSession(sessionId, "session_mismatch");
+                assistantRunState.clearRun(sessionId, "session_mismatch");
+                foregroundSessionState.markIdle(sessionId);
+                await scheduledTaskRuntime.flushDeferredDeliveries();
+                return;
+            }
+            const botApi = botInstance.api;
+            const chatId = chatIdInstance;
+            try {
+                assistantRunState.markResponseCompleted(sessionId, {
+                    agent: completionInfo.agent,
+                    providerID: completionInfo.providerID,
+                    modelID: completionInfo.modelID,
+                });
+                await finalizeAssistantResponse({
+                    sessionId,
+                    messageId,
+                    messageText,
+                    responseStreamer,
+                    flushPendingServiceMessages: () => Promise.all([
+                        toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
+                        toolCallStreamer.breakSession(sessionId, "assistant_message_completed"),
+                    ]).then(() => undefined),
+                    prepareStreamingPayload: prepareFinalStreamingPayload,
+                    renderFinalParts: (text) => renderAssistantFinalPartsSafe(text),
+                    getReplyKeyboard: getCurrentReplyKeyboard,
+                    sendRenderedPart: async (part, options) => {
+                        await sendRenderedBotPart({
+                            api: botApi,
+                            chatId,
+                            part,
+                            options: options,
+                        });
+                    },
+                });
+                await sendTtsResponseForSession({
+                    api: botApi,
+                    sessionId,
+                    chatId,
+                    text: messageText,
+                });
+            }
+            catch (err) {
+                clearPromptResponseMode(sessionId);
+                assistantRunState.clearRun(sessionId, "assistant_finalize_failed");
+                logger.error("Failed to send message to Telegram:", err);
+                // Stop processing events after critical error to prevent infinite loop
+                logger.error("[Bot] CRITICAL: Stopping event processing due to error");
+                summaryAggregator.clear();
+                foregroundSessionState.markIdle(sessionId);
+            }
+            finally {
+                await scheduledTaskRuntime.flushDeferredDeliveries();
+            }
+        });
     });
     summaryAggregator.setOnTool(async (toolInfo) => {
         if (!botInstance || !chatIdInstance) {
@@ -568,9 +576,54 @@ async function ensureEventSubscription(directory) {
             logger.error("[Bot] Error reloading context after compaction:", err);
         }
     });
+    summaryAggregator.setOnSessionIdle(async (sessionId) => {
+        await sessionCompletionTasks.get(sessionId)?.catch(() => undefined);
+        const completedRun = assistantRunState.finishRun(sessionId, "session_idle");
+        clearPromptResponseMode(sessionId);
+        if (!botInstance || !chatIdInstance) {
+            foregroundSessionState.markIdle(sessionId);
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+            return;
+        }
+        try {
+            await Promise.all([
+                toolMessageBatcher.flushSession(sessionId, "session_idle"),
+                toolCallStreamer.flushSession(sessionId, "session_idle"),
+            ]);
+            if (completedRun?.hasCompletedResponse) {
+                const agent = completedRun.actualAgent || completedRun.configuredAgent;
+                const providerID = completedRun.actualProviderID || completedRun.configuredProviderID;
+                const modelID = completedRun.actualModelID || completedRun.configuredModelID;
+                if (agent && providerID && modelID) {
+                    const keyboard = getCurrentReplyKeyboard();
+                    await botInstance.api.sendMessage(chatIdInstance, formatAssistantRunFooter({
+                        agent,
+                        providerID,
+                        modelID,
+                        elapsedMs: Date.now() - completedRun.startedAt,
+                    }), {
+                        ...(keyboard ? { reply_markup: keyboard } : {}),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.error("[Bot] Failed to send session idle footer:", err);
+        }
+        finally {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+        }
+    });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
         if (!botInstance || !chatIdInstance) {
             clearPromptResponseMode(sessionId);
+            assistantRunState.clearRun(sessionId, "session_error_no_bot_context");
             foregroundSessionState.markIdle(sessionId);
             return;
         }
@@ -579,12 +632,14 @@ async function ensureEventSubscription(directory) {
             clearPromptResponseMode(sessionId);
             responseStreamer.clearSession(sessionId, "session_error_not_current");
             toolCallStreamer.clearSession(sessionId, "session_error_not_current");
+            assistantRunState.clearRun(sessionId, "session_error_not_current");
             foregroundSessionState.markIdle(sessionId);
             await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
         }
         responseStreamer.clearSession(sessionId, "session_error");
         clearPromptResponseMode(sessionId);
+        assistantRunState.clearRun(sessionId, "session_error");
         await Promise.all([
             toolMessageBatcher.flushSession(sessionId, "session_error"),
             toolCallStreamer.flushSession(sessionId, "session_error"),
@@ -661,6 +716,8 @@ async function ensureEventSubscription(directory) {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
+    sessionCompletionTasks.clear();
+    assistantRunState.clearAll("bot_startup");
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;
@@ -736,6 +793,7 @@ export function createBot() {
     bot.command("opencode_start", opencodeStartCommand);
     bot.command("opencode_stop", opencodeStopCommand);
     bot.command("projects", projectsCommand);
+    bot.command("open", openCommand);
     bot.command("sessions", sessionsCommand);
     bot.command("new", newCommand);
     bot.command("abort", abortCommand);
@@ -753,8 +811,13 @@ export function createBot() {
         }
         try {
             const handledInlineCancel = await handleInlineMenuCancel(ctx);
+            if (handledInlineCancel) {
+                // Clean up path index when the open-directory menu is cancelled
+                clearOpenPathIndex();
+            }
             const handledSession = await handleSessionSelect(ctx);
             const handledProject = await handleProjectSelect(ctx);
+            const handledOpen = await handleOpenCallback(ctx);
             const handledQuestion = await handleQuestionCallback(ctx);
             const handledPermission = await handlePermissionCallback(ctx);
             const handledAgent = await handleAgentSelect(ctx);
@@ -765,10 +828,11 @@ export function createBot() {
             const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
+                !handledOpen &&
                 !handledQuestion &&
                 !handledPermission &&
                 !handledAgent &&

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

@@ -2,16 +2,22 @@ import { logger } from "../../utils/logger.js";
 function buildStateKey(sessionId, messageId) {
     return `${sessionId}:${messageId}`;
 }
+function clonePart(part) {
+    return {
+        text: part.text,
+        entities: part.entities ? [...part.entities] : undefined,
+        fallbackText: part.fallbackText,
+        source: part.source,
+    };
+}
 function normalizePayload(payload) {
-    const normalizedParts = payload.parts
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
+    const normalizedParts = payload.parts.map(clonePart).filter((part) => part.text.length > 0);
     if (normalizedParts.length === 0) {
+        logger.debug("[ResponseStreamer] Dropped empty streaming payload after normalization");
         return null;
     }
     return {
         parts: normalizedParts,
-        format: payload.format,
         sendOptions: payload.sendOptions,
         editOptions: payload.editOptions,
     };
@@ -37,8 +43,8 @@ function getRetryAfterMs(error) {
     }
     return seconds * 1000;
 }
-function createSignature(text, format) {
-    return `${format}\n${text}`;
+function createSignature(part) {
+    return `${part.text}\n${JSON.stringify(part.entities ?? null)}`;
 }
 function delay(ms) {
     return new Promise((resolve) => {
@@ -47,14 +53,14 @@ function delay(ms) {
 }
 export class ResponseStreamer {
     throttleMs;
-    sendText;
-    editText;
+    sendPart;
+    editPart;
     deleteText;
     states = new Map();
     constructor(options) {
         this.throttleMs = Math.max(0, Math.floor(options.throttleMs));
-        this.sendText = options.sendText;
-        this.editText = options.editText;
+        this.sendPart = options.sendPart;
+        this.editPart = options.editPart;
         this.deleteText = options.deleteText;
     }
     enqueue(sessionId, messageId, payload) {
@@ -73,6 +79,7 @@ export class ResponseStreamer {
         const notStreamed = { streamed: false, telegramMessageIds: [] };
         const state = this.states.get(buildStateKey(sessionId, messageId));
         if (!state) {
+            logger.debug(`[ResponseStreamer] Complete skipped, no active stream state: session=${sessionId}, message=${messageId}`);
             return notStreamed;
         }
         if (payload) {
@@ -90,6 +97,7 @@ export class ResponseStreamer {
             return notStreamed;
         }
         if (state.telegramMessageIds.length === 0) {
+            logger.debug(`[ResponseStreamer] Complete returned not streamed: session=${sessionId}, message=${messageId}, reason=no_visible_partials`);
             this.cancelState(state);
             this.states.delete(state.key);
             return notStreamed;
@@ -204,10 +212,11 @@ export class ResponseStreamer {
             if (!payload) {
                 return state.telegramMessageIds.length > 0;
             }
-            const targetSignatures = payload.parts.map((part) => createSignature(part, payload.format));
+            const targetSignatures = payload.parts.map((part) => createSignature(part));
             const unchanged = targetSignatures.length === state.lastSentSignatures.length &&
                 targetSignatures.every((signature, index) => signature === state.lastSentSignatures[index]);
             if (unchanged) {
+                logger.debug(`[ResponseStreamer] Skipped unchanged payload: session=${state.sessionId}, message=${state.messageId}, parts=${payload.parts.length}`);
                 return state.telegramMessageIds.length > 0;
             }
             try {
@@ -259,20 +268,20 @@ export class ResponseStreamer {
     }
     async syncMessages(state, payload, targetSignatures) {
         for (let index = 0; index < payload.parts.length; index++) {
-            const text = payload.parts[index];
+            const part = payload.parts[index];
             const nextSignature = targetSignatures[index];
             const currentMessageId = state.telegramMessageIds[index];
             if (currentMessageId) {
                 if (state.lastSentSignatures[index] === nextSignature) {
                     continue;
                 }
-                await this.editText(currentMessageId, text, payload.format, payload.editOptions);
-                state.lastSentSignatures[index] = nextSignature;
+                const result = await this.editPart(currentMessageId, part, payload.editOptions);
+                state.lastSentSignatures[index] = result.deliveredSignature;
                 continue;
             }
-            const messageId = await this.sendText(text, payload.format, payload.sendOptions);
-            state.telegramMessageIds[index] = messageId;
-            state.lastSentSignatures[index] = nextSignature;
+            const result = await this.sendPart(part, payload.sendOptions);
+            state.telegramMessageIds[index] = result.messageId;
+            state.lastSentSignatures[index] = result.deliveredSignature;
         }
         for (let index = state.telegramMessageIds.length - 1; index >= payload.parts.length; index--) {
             const messageId = state.telegramMessageIds[index];