@grinev/opencode-telegram-bot 0.13.0 → 0.13.2

package/dist/bot/commands/commands.js

@@ -19,9 +19,19 @@ const COMMANDS_CALLBACK_CANCEL = `${COMMANDS_CALLBACK_PREFIX}cancel`;
 const COMMANDS_CALLBACK_EXECUTE = `${COMMANDS_CALLBACK_PREFIX}execute`;
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
 function formatExecutingCommandMessage(commandName, args) {
-    const commandText = `／${commandName}`;
+    const prefix = t("commands.executing_prefix");
+    const commandText = `/${commandName}`;
     const argsSuffix = args ? ` ${args}` : "";
-    return `${t("commands.executing_prefix")}\n${commandText}${argsSuffix}`;
+    return {
+        text: `${prefix}\n${commandText}${argsSuffix}`,
+        entities: [
+            {
+                type: "code",
+                offset: prefix.length + 1,
+                length: commandText.length,
+            },
+        ],
+    };
 }
 export function buildCommandPageCallback(page) {
     return `${COMMANDS_CALLBACK_PAGE_PREFIX}${page}`;
@@ -181,7 +191,10 @@ async function getCommandList(projectDirectory) {
         throw error || new Error("No command data received");
     }
     return data
-        .filter((command) => typeof command.name === "string" && command.name.trim().length > 0)
+        .filter((command) => {
+        const source = command.source;
+        return (typeof command.name === "string" && command.name.trim().length > 0 && source === "command");
+    })
         .map((command) => ({
         name: command.name,
         description: command.description,
@@ -252,7 +265,8 @@ async function executeCommand(ctx, deps, params) {
         return;
     }
     const args = params.argumentsText.trim();
-    await ctx.reply(formatExecutingCommandMessage(params.commandName, args));
+    const executingMessage = formatExecutingCommandMessage(params.commandName, args);
+    await ctx.reply(executingMessage.text, { entities: executingMessage.entities });
     const session = await ensureSessionForProject(ctx, params.projectDirectory);
     if (!session) {
         return;

package/dist/bot/index.js

@@ -56,6 +56,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;
@@ -187,6 +188,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();
@@ -221,6 +274,7 @@ async function ensureEventSubscription(directory) {
     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) => {
@@ -246,12 +300,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;
@@ -265,7 +321,10 @@ async function ensureEventSubscription(directory) {
                 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"),
@@ -315,7 +374,7 @@ async function ensureEventSubscription(directory) {
         try {
             const message = formatToolInfo(toolInfo);
             if (message) {
-                toolMessageBatcher.enqueue(toolInfo.sessionId, message);
+                toolCallStreamer.append(toolInfo.sessionId, message);
             }
         }
         catch (err) {
@@ -332,6 +391,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 +410,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 +445,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,6 +461,7 @@ 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,
@@ -451,12 +518,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 +553,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()) {

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

@@ -0,0 +1,285 @@
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_MESSAGE_SAFE_LENGTH = 4000;
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function getRetryAfterMs(error) {
+    const message = getErrorMessage(error);
+    if (!/\b429\b/.test(message)) {
+        return null;
+    }
+    const retryMatch = message.match(/retry after\s+(\d+)/i);
+    if (!retryMatch) {
+        return null;
+    }
+    const seconds = Number.parseInt(retryMatch[1], 10);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return null;
+    }
+    return seconds * 1000;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function 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;
+}
+function buildParts(entries) {
+    const text = entries
+        .map((entry) => entry.text.trim())
+        .filter(Boolean)
+        .join("\n\n");
+    if (!text) {
+        return [];
+    }
+    return splitLongText(text, TELEGRAM_MESSAGE_SAFE_LENGTH).filter(Boolean);
+}
+export class ToolCallStreamer {
+    throttleMs;
+    sendText;
+    editText;
+    deleteText;
+    states = new Map();
+    allStates = new Set();
+    constructor(options) {
+        this.throttleMs = Math.max(0, Math.floor(options.throttleMs));
+        this.sendText = options.sendText;
+        this.editText = options.editText;
+        this.deleteText = options.deleteText;
+    }
+    append(sessionId, text) {
+        const normalizedText = text.trim();
+        if (!sessionId || !normalizedText) {
+            return;
+        }
+        const state = this.getOrCreateState(sessionId);
+        state.entries.push({ text: normalizedText });
+        state.latestParts = buildParts(state.entries);
+        this.ensureTimer(state);
+    }
+    replaceByPrefix(sessionId, prefix, text) {
+        const normalizedPrefix = prefix.trim();
+        const normalizedText = text.trim();
+        if (!sessionId || !normalizedPrefix || !normalizedText) {
+            return;
+        }
+        const state = this.getOrCreateState(sessionId);
+        const existingEntry = state.entries.find((entry) => entry.prefix === normalizedPrefix);
+        if (existingEntry) {
+            existingEntry.text = normalizedText;
+        }
+        else {
+            state.entries.push({ prefix: normalizedPrefix, text: normalizedText });
+        }
+        state.latestParts = buildParts(state.entries);
+        this.ensureTimer(state);
+    }
+    async flushSession(sessionId, reason) {
+        const state = this.states.get(sessionId);
+        if (!state) {
+            return;
+        }
+        this.clearTimer(state);
+        await this.enqueueTask(state, () => this.syncState(state, reason));
+    }
+    async breakSession(sessionId, reason) {
+        const state = this.states.get(sessionId);
+        if (!state) {
+            return;
+        }
+        state.isBreaking = true;
+        this.getOrCreateState(sessionId);
+        this.clearTimer(state);
+        await this.enqueueTask(state, () => this.syncState(state, reason));
+        this.cancelState(state);
+        this.removeState(state);
+        logger.debug(`[ToolCallStreamer] Broke session stream: session=${sessionId}, reason=${reason}`);
+    }
+    clearSession(sessionId, reason) {
+        let clearedAny = false;
+        for (const state of Array.from(this.allStates)) {
+            if (state.sessionId !== sessionId) {
+                continue;
+            }
+            this.cancelState(state);
+            this.removeState(state);
+            clearedAny = true;
+        }
+        if (clearedAny) {
+            logger.debug(`[ToolCallStreamer] Cleared session stream: session=${sessionId}, reason=${reason}`);
+        }
+    }
+    clearAll(reason) {
+        for (const state of Array.from(this.allStates)) {
+            this.cancelState(state);
+        }
+        const count = this.allStates.size;
+        this.states.clear();
+        this.allStates.clear();
+        if (count > 0) {
+            logger.debug(`[ToolCallStreamer] Cleared all streams: count=${count}, reason=${reason}`);
+        }
+    }
+    getOrCreateState(sessionId) {
+        const existing = this.states.get(sessionId);
+        if (existing && !existing.isBroken && !existing.cancelled && !existing.isBreaking) {
+            return existing;
+        }
+        if (existing && (existing.isBroken || existing.cancelled)) {
+            this.clearTimer(existing);
+            this.removeState(existing);
+        }
+        const state = {
+            sessionId,
+            entries: [],
+            latestParts: [],
+            lastSentParts: [],
+            telegramMessageIds: [],
+            timer: null,
+            task: Promise.resolve(true),
+            cancelled: false,
+            isBroken: false,
+            isBreaking: false,
+            fatalErrorMessage: null,
+            fatalErrorLogged: false,
+        };
+        this.states.set(sessionId, state);
+        this.allStates.add(state);
+        return state;
+    }
+    clearTimer(state) {
+        if (!state.timer) {
+            return;
+        }
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    ensureTimer(state) {
+        if (state.timer || state.isBroken || state.cancelled) {
+            return;
+        }
+        if (this.throttleMs === 0) {
+            void this.enqueueTask(state, () => this.syncState(state, "immediate")).catch((error) => {
+                logger.error(`[ToolCallStreamer] Immediate sync failed: session=${state.sessionId}`, error);
+            });
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = null;
+            void this.enqueueTask(state, () => this.syncState(state, "throttle_elapsed")).catch((error) => {
+                logger.error(`[ToolCallStreamer] Throttled sync failed: session=${state.sessionId}`, error);
+            });
+        }, this.throttleMs);
+    }
+    enqueueTask(state, task) {
+        const nextTask = state.task.catch(() => false).then(task);
+        state.task = nextTask;
+        return nextTask;
+    }
+    cancelState(state) {
+        state.cancelled = true;
+        this.clearTimer(state);
+    }
+    removeState(state) {
+        if (this.states.get(state.sessionId) === state) {
+            this.states.delete(state.sessionId);
+        }
+        this.allStates.delete(state);
+    }
+    async syncState(state, reason) {
+        if (state.cancelled) {
+            return false;
+        }
+        if (state.isBroken) {
+            return false;
+        }
+        while (!state.isBroken && !state.cancelled) {
+            const parts = state.latestParts;
+            const unchanged = parts.length === state.lastSentParts.length &&
+                parts.every((part, index) => state.lastSentParts[index] === part);
+            if (unchanged) {
+                return state.telegramMessageIds.length > 0;
+            }
+            if (parts.length === 0) {
+                return state.telegramMessageIds.length > 0;
+            }
+            try {
+                await this.syncMessages(state, parts);
+                if (state.cancelled) {
+                    return false;
+                }
+                logger.debug(`[ToolCallStreamer] Stream synced: session=${state.sessionId}, reason=${reason}, parts=${parts.length}`);
+                return true;
+            }
+            catch (error) {
+                const retryAfterMs = getRetryAfterMs(error);
+                if (retryAfterMs === null) {
+                    this.markStreamBroken(state, error, reason);
+                    return false;
+                }
+                const delayMs = Math.max(this.throttleMs, retryAfterMs);
+                logger.warn(`[ToolCallStreamer] Stream sync rate-limited, retrying in ${delayMs}ms: session=${state.sessionId}, reason=${reason}`, error);
+                await delay(delayMs);
+            }
+        }
+        return false;
+    }
+    markStreamBroken(state, error, reason) {
+        state.isBroken = true;
+        state.fatalErrorMessage = getErrorMessage(error);
+        if (state.fatalErrorLogged) {
+            return;
+        }
+        state.fatalErrorLogged = true;
+        logger.error(`[ToolCallStreamer] Stream marked as broken: session=${state.sessionId}, reason=${reason}, error=${state.fatalErrorMessage}`, error);
+    }
+    async syncMessages(state, parts) {
+        for (let index = 0; index < parts.length; index++) {
+            if (state.cancelled) {
+                return;
+            }
+            const text = parts[index];
+            const currentMessageId = state.telegramMessageIds[index];
+            if (currentMessageId) {
+                await this.editText(state.sessionId, currentMessageId, text);
+                state.lastSentParts[index] = text;
+                continue;
+            }
+            const messageId = await this.sendText(state.sessionId, text);
+            state.telegramMessageIds[index] = messageId;
+            state.lastSentParts[index] = text;
+        }
+        for (let index = state.telegramMessageIds.length - 1; index >= parts.length; index--) {
+            if (state.cancelled) {
+                return;
+            }
+            const messageId = state.telegramMessageIds[index];
+            if (messageId) {
+                await this.deleteText(state.sessionId, messageId);
+            }
+            state.telegramMessageIds.pop();
+            state.lastSentParts.pop();
+        }
+    }
+}

package/dist/bot/utils/thinking-message.js

@@ -4,9 +4,6 @@ export function deliverThinkingMessage(sessionId, batcher, options) {
         return;
     }
     const message = t("bot.thinking");
-    if (options.responseStreaming) {
-        batcher.sendTextNow(sessionId, message, "thinking_started_streaming");
-        return;
-    }
-    batcher.enqueue(sessionId, message);
+    void options.responseStreaming;
+    batcher.sendTextNow(sessionId, message, "thinking_started");
 }

package/dist/i18n/de.js

@@ -273,7 +273,7 @@ export const de = {
     "task.schedule_too_frequent": "Der wiederkehrende Zeitplan ist zu häufig. Das minimale erlaubte Intervall ist einmal alle 5 Minuten.",
     "task.kind.cron": "wiederkehrend",
     "task.kind.once": "einmalig",
-    "task.run.success": "⏰ Geplante Aufgabe abgeschlossen: {description}\n\n{result}",
+    "task.run.success": "⏰ Geplante Aufgabe abgeschlossen: {description}",
     "task.run.error": "🔴 Geplante Aufgabe fehlgeschlagen: {description}\n\nFehler: {error}",
     "tasklist.empty": "📭 Noch keine geplanten Aufgaben.",
     "tasklist.select": "Wähle eine geplante Aufgabe:",

package/dist/i18n/en.js

@@ -273,7 +273,7 @@ export const en = {
     "task.schedule_too_frequent": "Recurring schedule is too frequent. The minimum allowed interval is once every 5 minutes.",
     "task.kind.cron": "recurring",
     "task.kind.once": "one-time",
-    "task.run.success": "⏰ Scheduled task completed: {description}\n\n{result}",
+    "task.run.success": "⏰ Scheduled task completed: {description}",
     "task.run.error": "🔴 Scheduled task failed: {description}\n\nError: {error}",
     "tasklist.empty": "📭 No scheduled tasks yet.",
     "tasklist.select": "Select a scheduled task:",

package/dist/i18n/es.js

@@ -273,7 +273,7 @@ export const es = {
     "task.schedule_too_frequent": "El horario recurrente es demasiado frecuente. El intervalo mínimo permitido es una vez cada 5 minutos.",
     "task.kind.cron": "recurrente",
     "task.kind.once": "única",
-    "task.run.success": "⏰ Tarea programada completada: {description}\n\n{result}",
+    "task.run.success": "⏰ Tarea programada completada: {description}",
     "task.run.error": "🔴 La tarea programada falló: {description}\n\nError: {error}",
     "tasklist.empty": "📭 Aún no hay tareas programadas.",
     "tasklist.select": "Elige una tarea programada:",

package/dist/i18n/fr.js

@@ -273,7 +273,7 @@ export const fr = {
     "task.schedule_too_frequent": "Le planning récurrent est trop fréquent. L'intervalle minimum autorisé est d'une fois toutes les 5 minutes.",
     "task.kind.cron": "récurrente",
     "task.kind.once": "ponctuelle",
-    "task.run.success": "⏰ Tâche planifiée terminée : {description}\n\n{result}",
+    "task.run.success": "⏰ Tâche planifiée terminée : {description}",
     "task.run.error": "🔴 Échec de la tâche planifiée : {description}\n\nErreur : {error}",
     "tasklist.empty": "📭 Aucune tâche planifiée pour le moment.",
     "tasklist.select": "Sélectionnez une tâche planifiée :",

package/dist/i18n/ru.js

@@ -273,7 +273,7 @@ export const ru = {
     "task.schedule_too_frequent": "Повторяющееся расписание слишком частое. Минимально допустимый интервал - один запуск в 5 минут.",
     "task.kind.cron": "повторяющаяся",
     "task.kind.once": "однократная",
-    "task.run.success": "⏰ Задача по расписанию выполнена: {description}\n\n{result}",
+    "task.run.success": "⏰ Задача по расписанию выполнена: {description}",
     "task.run.error": "🔴 Ошибка выполнения задачи по расписанию: {description}\n\nОшибка: {error}",
     "tasklist.empty": "📭 Задач по расписанию пока нет.",
     "tasklist.select": "Выберите задачу по расписанию:",

package/dist/i18n/zh.js

@@ -273,7 +273,7 @@ export const zh = {
     "task.schedule_too_frequent": "重复任务过于频繁。最小允许间隔为每 5 分钟一次。",
     "task.kind.cron": "重复",
     "task.kind.once": "一次性",
-    "task.run.success": "⏰ 定时任务已完成: {description}\n\n{result}",
+    "task.run.success": "⏰ 定时任务已完成: {description}",
     "task.run.error": "🔴 定时任务执行失败: {description}\n\n错误: {error}",
     "tasklist.empty": "📭 还没有定时任务。",
     "tasklist.select": "请选择一个定时任务：",

package/dist/scheduled-task/runtime.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { escapePlainTextForTelegramMarkdownV2, formatSummaryWithMode, } from "../summary/formatter.js";
 import { t } from "../i18n/index.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
@@ -7,28 +8,30 @@ import { executeScheduledTask } from "./executor.js";
 import { foregroundSessionState } from "./foreground-state.js";
 import { computeNextRunAt, isTaskDue } from "./next-run.js";
 import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
-const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
 const TASK_DESCRIPTION_PREVIEW_LENGTH = 64;
 const RESTART_INTERRUPTED_ERROR = "Interrupted by bot restart during scheduled task execution.";
-function splitTelegramText(text) {
-    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
-        return [text];
+function getScheduledTaskDeliveryFormat() {
+    return config.bot.messageFormatMode === "markdown" ? "markdown_v2" : "raw";
+}
+function buildScheduledTaskSuccessMessageParts(delivery) {
+    if (!delivery.resultText) {
+        return [delivery.notificationText];
     }
-    const parts = [];
-    let remaining = text;
-    while (remaining.length > TELEGRAM_MESSAGE_LIMIT) {
-        let splitIndex = remaining.lastIndexOf("\n", TELEGRAM_MESSAGE_LIMIT);
-        if (splitIndex <= 0 || splitIndex < Math.floor(TELEGRAM_MESSAGE_LIMIT * 0.5)) {
-            splitIndex = TELEGRAM_MESSAGE_LIMIT;
-        }
-        parts.push(remaining.slice(0, splitIndex).trim());
-        remaining = remaining.slice(splitIndex).trimStart();
+    if (config.bot.messageFormatMode !== "markdown") {
+        return formatSummaryWithMode(`${delivery.notificationText}\n\n${delivery.resultText}`, config.bot.messageFormatMode);
+    }
+    const header = escapePlainTextForTelegramMarkdownV2(delivery.notificationText);
+    const resultParts = formatSummaryWithMode(delivery.resultText, config.bot.messageFormatMode);
+    if (resultParts.length === 0) {
+        return [header];
     }
-    if (remaining.trim()) {
-        parts.push(remaining.trim());
+    const firstPart = `${header}\n\n${resultParts[0]}`;
+    if (firstPart.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return [firstPart, ...resultParts.slice(1)];
     }
-    return parts;
+    return [header, ...resultParts];
 }
 function normalizeTaskPrompt(prompt) {
     const normalized = prompt.replace(/\s+/g, " ").trim();
@@ -44,10 +47,10 @@ function buildSuccessDelivery(task, runAt, resultText) {
         prompt: task.prompt,
         runAt,
         status: "success",
-        messageText: t("task.run.success", {
+        notificationText: t("task.run.success", {
             description: normalizeTaskPrompt(task.prompt),
-            result: resultText,
         }),
+        resultText,
     };
 }
 function buildErrorDelivery(task, runAt, errorMessage) {
@@ -57,7 +60,7 @@ function buildErrorDelivery(task, runAt, errorMessage) {
         prompt: task.prompt,
         runAt,
         status: "error",
-        messageText: t("task.run.error", {
+        notificationText: t("task.run.error", {
             description: normalizeTaskPrompt(task.prompt),
             error: errorMessage,
         }),
@@ -342,13 +345,16 @@ export class ScheduledTaskRuntime {
             return false;
         }
         try {
-            const messageParts = splitTelegramText(delivery.messageText);
+            const messageParts = delivery.status === "success"
+                ? buildScheduledTaskSuccessMessageParts(delivery)
+                : [delivery.notificationText];
+            const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
             for (const part of messageParts) {
                 await sendBotText({
                     api: this.botApi,
                     chatId: this.chatId,
                     text: part,
-                    format: "raw",
+                    format,
                 });
             }
             return true;

package/dist/summary/formatter.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
 function splitText(text, maxLength) {
     const parts = [];
     let currentIndex = 0;
@@ -134,16 +135,48 @@ export function getAssistantParseMode() {
     }
     return undefined;
 }
+export function escapePlainTextForTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
+}
 function formatMarkdownForTelegram(text) {
     try {
         const preprocessed = preprocessMarkdownForTelegram(text);
-        return convert(preprocessed, "keep");
+        return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
     }
     catch (error) {
         logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
         return text;
     }
 }
+function escapeMarkdownV2PipesOutsideCode(text) {
+    let result = "";
+    let index = 0;
+    let inInlineCode = false;
+    let inCodeFence = false;
+    while (index < text.length) {
+        if (text.startsWith("```", index)) {
+            result += "```";
+            index += 3;
+            inCodeFence = !inCodeFence;
+            continue;
+        }
+        const char = text[index];
+        if (!inCodeFence && char === "`") {
+            inInlineCode = !inInlineCode;
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (!inCodeFence && !inInlineCode && char === "|" && text[index - 1] !== "\\") {
+            result += "\\|";
+            index += 1;
+            continue;
+        }
+        result += char;
+        index += 1;
+    }
+    return result;
+}
 export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_LIMIT) {
     if (!text || text.trim().length === 0) {
         return [];

package/package.json

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