@grinev/opencode-telegram-bot 0.13.1 → 0.14.0

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/finalize-assistant-response.js

@@ -1,16 +1,25 @@
-export async function finalizeAssistantResponse({ responseStreaming, sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, }) {
-    let streamedViaMessages = false;
-    if (responseStreaming) {
-        const preparedStreamPayload = prepareStreamingPayload(messageText);
-        if (preparedStreamPayload) {
-            preparedStreamPayload.sendOptions = undefined;
-            preparedStreamPayload.editOptions = undefined;
-        }
-        streamedViaMessages = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+import { logger } from "../../utils/logger.js";
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
+    let streamedMessageIds = [];
+    const preparedStreamPayload = prepareStreamingPayload(messageText);
+    if (preparedStreamPayload) {
+        preparedStreamPayload.sendOptions = { disable_notification: true };
+        preparedStreamPayload.editOptions = undefined;
+    }
+    const result = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+    if (result.streamed) {
+        streamedMessageIds = result.telegramMessageIds;
     }
     await flushPendingServiceMessages();
-    if (streamedViaMessages) {
-        return true;
+    // When the response was streamed, delete the streamed messages and re-send
+    // via the non-streamed path so the reply keyboard carries the latest context.
+    if (streamedMessageIds.length > 0) {
+        try {
+            await deleteMessages(streamedMessageIds);
+        }
+        catch (err) {
+            logger.warn("[FinalizeResponse] Failed to delete streamed messages, sending with keyboard anyway:", err);
+        }
     }
     const parts = formatSummary(messageText);
     const format = resolveFormat();

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -6,6 +6,17 @@ const MARKDOWN_PARSE_ERROR_MARKERS = [
     "entity beginning",
     "bad request: can't parse",
 ];
+function stripMarkdownFormattingOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const rawOptions = {
+        ...options,
+    };
+    delete rawOptions.parse_mode;
+    delete rawOptions.entities;
+    return rawOptions;
+}
 function getErrorText(error) {
     const parts = [];
     if (error instanceof Error) {
@@ -52,7 +63,7 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, optio
             throw error;
         }
         logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
-        return api.sendMessage(chatId, text, options);
+        return api.sendMessage(chatId, text, stripMarkdownFormattingOptions(options));
     }
 }
 export async function editMessageWithMarkdownFallback({ api, chatId, messageId, text, options, parseMode, }) {
@@ -71,6 +82,6 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
             throw error;
         }
         logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
-        return api.editMessageText(chatId, messageId, text, options);
+        return api.editMessageText(chatId, messageId, text, stripMarkdownFormattingOptions(options));
     }
 }

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

@@ -4,9 +4,5 @@ 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);
+    batcher.sendTextNow(sessionId, message, "thinking_started");
 }

package/dist/config.js

@@ -21,20 +21,6 @@ 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);
     return normalizeLocale(value, defaultValue);
@@ -88,10 +74,8 @@ export const config = {
         commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
         taskLimit: getOptionalPositiveIntEnvVar("TASK_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),
-        responseStreaming: getOptionalBooleanEnvVar("RESPONSE_STREAMING", true),
         messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
     },
     files: {

package/dist/i18n/de.js

@@ -217,6 +217,18 @@ export const de = {
     "pinned.line.model": "Modell: {model}",
     "pinned.line.context": "Kontext: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Kosten: {cost} ausgegeben",
+    "subagent.header": "Subagent {agent}: {description}",
+    "subagent.line.status": "Status: {status}",
+    "subagent.line.task": "Aufgabe: {task}",
+    "subagent.line.agent": "Agent: {agent}",
+    "subagent.working": "Arbeitet...",
+    "subagent.working_with_details": "Arbeitet: {details}",
+    "subagent.completed": "Abgeschlossen",
+    "subagent.failed": "Aufgabe fehlgeschlagen",
+    "subagent.status.pending": "ausstehend",
+    "subagent.status.running": "laeuft",
+    "subagent.status.completed": "abgeschlossen",
+    "subagent.status.error": "Fehler",
     "pinned.files.title": "Dateien ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... und {count} mehr",
@@ -273,7 +285,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

@@ -217,6 +217,18 @@ export const en = {
     "pinned.line.model": "Model: {model}",
     "pinned.line.context": "Context: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Cost: {cost} spent",
+    "subagent.header": "Subagent {agent}: {description}",
+    "subagent.line.status": "Status: {status}",
+    "subagent.line.task": "Task: {task}",
+    "subagent.line.agent": "Agent: {agent}",
+    "subagent.working": "Working...",
+    "subagent.working_with_details": "Working: {details}",
+    "subagent.completed": "Completed",
+    "subagent.failed": "Task failed",
+    "subagent.status.pending": "pending",
+    "subagent.status.running": "running",
+    "subagent.status.completed": "completed",
+    "subagent.status.error": "error",
     "pinned.files.title": "Files ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... and {count} more",
@@ -273,7 +285,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

@@ -217,6 +217,18 @@ export const es = {
     "pinned.line.model": "Modelo: {model}",
     "pinned.line.context": "Contexto: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Costo: {cost} gastado",
+    "subagent.header": "Subagente {agent}: {description}",
+    "subagent.line.status": "Estado: {status}",
+    "subagent.line.task": "Tarea: {task}",
+    "subagent.line.agent": "Agente: {agent}",
+    "subagent.working": "Trabajando...",
+    "subagent.working_with_details": "Trabajando: {details}",
+    "subagent.completed": "Completada",
+    "subagent.failed": "Error de tarea",
+    "subagent.status.pending": "pendiente",
+    "subagent.status.running": "en ejecucion",
+    "subagent.status.completed": "completado",
+    "subagent.status.error": "error",
     "pinned.files.title": "Archivos ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... y {count} más",
@@ -273,7 +285,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

@@ -217,6 +217,18 @@ export const fr = {
     "pinned.line.model": "Modèle : {model}",
     "pinned.line.context": "Contexte : {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Coût : {cost} dépensé",
+    "subagent.header": "Sous-agent {agent} : {description}",
+    "subagent.line.status": "Statut : {status}",
+    "subagent.line.task": "Tache : {task}",
+    "subagent.line.agent": "Agent : {agent}",
+    "subagent.working": "En cours...",
+    "subagent.working_with_details": "En cours : {details}",
+    "subagent.completed": "Terminee",
+    "subagent.failed": "Echec de la tache",
+    "subagent.status.pending": "en attente",
+    "subagent.status.running": "en cours",
+    "subagent.status.completed": "termine",
+    "subagent.status.error": "erreur",
     "pinned.files.title": "Fichiers ({count}) :",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... et encore {count}",
@@ -273,7 +285,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

@@ -217,6 +217,18 @@ export const ru = {
     "pinned.line.model": "Модель: {model}",
     "pinned.line.context": "Контекст: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Стоимость: {cost} потрачено",
+    "subagent.header": "Сабагент {agent}: {description}",
+    "subagent.line.status": "Статус: {status}",
+    "subagent.line.task": "Задача: {task}",
+    "subagent.line.agent": "Агент: {agent}",
+    "subagent.working": "В работе...",
+    "subagent.working_with_details": "В работе: {details}",
+    "subagent.completed": "Завершена",
+    "subagent.failed": "Ошибка задачи",
+    "subagent.status.pending": "ожидание",
+    "subagent.status.running": "в работе",
+    "subagent.status.completed": "завершен",
+    "subagent.status.error": "ошибка",
     "pinned.files.title": "Файлы ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... и еще {count}",
@@ -273,7 +285,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

@@ -217,6 +217,18 @@ export const zh = {
     "pinned.line.model": "模型: {model}",
     "pinned.line.context": "上下文: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "费用: {cost}",
+    "subagent.header": "子代理 {agent}: {description}",
+    "subagent.line.status": "状态: {status}",
+    "subagent.line.task": "任务: {task}",
+    "subagent.line.agent": "代理: {agent}",
+    "subagent.working": "执行中...",
+    "subagent.working_with_details": "执行中: {details}",
+    "subagent.completed": "已完成",
+    "subagent.failed": "任务失败",
+    "subagent.status.pending": "等待中",
+    "subagent.status.running": "运行中",
+    "subagent.status.completed": "已完成",
+    "subagent.status.error": "错误",
     "pinned.files.title": "文件（{count}）：",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... 还有 {count} 个",
@@ -273,7 +285,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/model/context-limit.js

@@ -0,0 +1,57 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+import { DEFAULT_CONTEXT_LIMIT } from "../pinned/format.js";
+const PROVIDER_CACHE_TTL_MS = 10 * 60 * 1000;
+const contextLimitCache = new Map();
+let providersCacheExpiresAt = 0;
+let providersFetchInFlight = null;
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+async function refreshContextLimitCache() {
+    if (Date.now() < providersCacheExpiresAt) {
+        return;
+    }
+    if (providersFetchInFlight) {
+        await providersFetchInFlight;
+        return;
+    }
+    providersFetchInFlight = (async () => {
+        try {
+            const { data, error } = await opencodeClient.config.providers();
+            if (error || !data) {
+                logger.warn("[ModelContextLimit] Failed to fetch providers:", error);
+                return;
+            }
+            contextLimitCache.clear();
+            for (const provider of data.providers) {
+                for (const [modelID, model] of Object.entries(provider.models)) {
+                    if (model?.limit?.context) {
+                        contextLimitCache.set(getModelKey(provider.id, modelID), model.limit.context);
+                    }
+                }
+            }
+            providersCacheExpiresAt = Date.now() + PROVIDER_CACHE_TTL_MS;
+            logger.debug(`[ModelContextLimit] Cached limits for ${contextLimitCache.size} provider/model pairs`);
+        }
+        catch (error) {
+            logger.warn("[ModelContextLimit] Error refreshing providers cache:", error);
+        }
+        finally {
+            providersFetchInFlight = null;
+        }
+    })();
+    await providersFetchInFlight;
+}
+export async function getModelContextLimit(providerID, modelID) {
+    if (!providerID || !modelID) {
+        return DEFAULT_CONTEXT_LIMIT;
+    }
+    const cacheKey = getModelKey(providerID, modelID);
+    const cachedLimit = contextLimitCache.get(cacheKey);
+    if (cachedLimit) {
+        return cachedLimit;
+    }
+    await refreshContextLimitCache();
+    return contextLimitCache.get(cacheKey) ?? DEFAULT_CONTEXT_LIMIT;
+}

package/dist/pinned/format.js

@@ -0,0 +1,29 @@
+import { t } from "../i18n/index.js";
+export const DEFAULT_CONTEXT_LIMIT = 200000;
+export function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return count.toString();
+}
+export function formatModelDisplayName(providerID, modelID) {
+    if (providerID && modelID) {
+        return `${providerID}/${modelID}`;
+    }
+    return t("pinned.unknown");
+}
+export function formatContextLine(tokensUsed, tokensLimit) {
+    const safeLimit = typeof tokensLimit === "number" && tokensLimit > 0 ? tokensLimit : null;
+    const percentage = safeLimit ? Math.round((tokensUsed / safeLimit) * 100) : 0;
+    return t("pinned.line.context", {
+        used: formatTokenCount(tokensUsed),
+        limit: safeLimit ? formatTokenCount(safeLimit) : t("pinned.unknown"),
+        percent: percentage,
+    });
+}
+export function formatCostLine(cost) {
+    return t("pinned.line.cost", { cost: `$${cost.toFixed(2)}` });
+}