@grinev/opencode-telegram-bot 0.13.1 → 0.14.0

package/dist/pinned/manager.js

@@ -3,7 +3,9 @@ import { opencodeClient } from "../opencode/client.js";
 import { getCurrentSession } from "../session/manager.js";
 import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
 import { getStoredModel } from "../model/manager.js";
+import { getModelContextLimit } from "../model/context-limit.js";
 import { t } from "../i18n/index.js";
+import { DEFAULT_CONTEXT_LIMIT, formatContextLine, formatCostLine, formatModelDisplayName, } from "./format.js";
 class PinnedMessageManager {
     api = null;
     chatId = null;
@@ -147,6 +149,22 @@ class PinnedMessageManager {
         await this.refreshSessionTitle();
         await this.updatePinnedMessage();
     }
+    /**
+     * Update tokens in memory without triggering an API call.
+     * Used for intermediate (non-completed) message.updated events
+     * to keep pinned state in sync with keyboardManager.
+     */
+    updateTokensSilent(tokens) {
+        this.state.tokensUsed = tokens.input + tokens.cacheRead;
+        logger.debug(`[PinnedManager] Tokens updated (silent): ${this.state.tokensUsed}/${this.state.tokensLimit}`);
+    }
+    /**
+     * Refresh the pinned message with current in-memory state.
+     * Used at thinking time to push accumulated silent updates to Telegram.
+     */
+    async refresh() {
+        await this.updatePinnedMessage();
+    }
     /**
      * Called when cost info is received from SSE events
      */
@@ -162,6 +180,12 @@ class PinnedMessageManager {
     setOnKeyboardUpdate(callback) {
         this.onKeyboardUpdateCallback = callback;
         logger.debug("[PinnedManager] Keyboard update callback registered");
+        // Fire immediately with current state to fix race condition:
+        // onSessionChange may have already run before this callback was registered.
+        const limit = this.state.tokensLimit > 0 ? this.state.tokensLimit : this.contextLimit || 0;
+        if (limit > 0) {
+            callback(this.state.tokensUsed, limit);
+        }
     }
     /**
      * Get current context information
@@ -412,38 +436,13 @@ class PinnedMessageManager {
     async fetchContextLimit() {
         try {
             const model = getStoredModel();
-            if (!model.providerID || !model.modelID) {
-                logger.warn("[PinnedManager] No model configured, using default limit");
-                this.contextLimit = 200000;
-                this.state.tokensLimit = this.contextLimit;
-                return;
-            }
-            const { data: providersData, error } = await opencodeClient.config.providers();
-            if (error || !providersData) {
-                logger.warn("[PinnedManager] Failed to fetch providers, using default limit");
-                this.contextLimit = 200000;
-                this.state.tokensLimit = this.contextLimit;
-                return;
-            }
-            // Find the model in providers
-            for (const provider of providersData.providers) {
-                if (provider.id === model.providerID) {
-                    const modelInfo = provider.models[model.modelID];
-                    if (modelInfo?.limit?.context) {
-                        this.contextLimit = modelInfo.limit.context;
-                        this.state.tokensLimit = this.contextLimit;
-                        logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
-                        return;
-                    }
-                }
-            }
-            logger.warn("[PinnedManager] Model not found in providers, using default limit");
-            this.contextLimit = 200000;
+            this.contextLimit = await getModelContextLimit(model.providerID, model.modelID);
             this.state.tokensLimit = this.contextLimit;
+            logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
         }
         catch (err) {
             logger.error("[PinnedManager] Error fetching context limit:", err);
-            this.contextLimit = 200000;
+            this.contextLimit = DEFAULT_CONTEXT_LIMIT;
             this.state.tokensLimit = this.contextLimit;
         }
     }
@@ -451,28 +450,16 @@ class PinnedMessageManager {
      * Format the pinned message text
      */
     formatMessage() {
-        const percentage = this.state.tokensLimit > 0
-            ? Math.round((this.state.tokensUsed / this.state.tokensLimit) * 100)
-            : 0;
-        const tokensFormatted = this.formatTokenCount(this.state.tokensUsed);
-        const limitFormatted = this.formatTokenCount(this.state.tokensLimit);
-        // Get current model info
         const currentModel = getStoredModel();
-        const modelName = currentModel.providerID && currentModel.modelID
-            ? `${currentModel.providerID}/${currentModel.modelID}`
-            : t("pinned.unknown");
+        const modelName = formatModelDisplayName(currentModel.providerID, currentModel.modelID);
         const lines = [
             `${this.state.sessionTitle}`,
             t("pinned.line.project", { project: this.state.projectName }),
             t("pinned.line.model", { model: modelName }),
-            t("pinned.line.context", {
-                used: tokensFormatted,
-                limit: limitFormatted,
-                percent: percentage,
-            }),
+            formatContextLine(this.state.tokensUsed, this.state.tokensLimit),
         ];
         if (this.state.cost !== undefined && this.state.cost !== null) {
-            lines.push(t("pinned.line.cost", { cost: `$${this.state.cost.toFixed(2)}` }));
+            lines.push(formatCostLine(this.state.cost));
         }
         if (this.state.changedFiles.length > 0) {
             const maxFiles = 10;
@@ -496,18 +483,6 @@ class PinnedMessageManager {
         }
         return lines.join("\n");
     }
-    /**
-     * Format token count (e.g., 150000 -> "150K")
-     */
-    formatTokenCount(count) {
-        if (count >= 1000000) {
-            return `${(count / 1000000).toFixed(1)}M`;
-        }
-        else if (count >= 1000) {
-            return `${Math.round(count / 1000)}K`;
-        }
-        return count.toString();
-    }
     /**
      * Create and pin a new status message
      */

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;