@grinev/opencode-telegram-bot 0.13.2 → 0.14.1

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",

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",

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",

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}",

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}",

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} 个",

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)}` });
+}

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;
@@ -21,6 +23,11 @@ class PinnedMessageManager {
     };
     contextLimit = null;
     onKeyboardUpdateCallback;
+    updateDebounceTimer = null;
+    updateTask = null;
+    pendingUpdate = false;
+    pendingForceUpdate = false;
+    lastRenderedMessageText = null;
     /**
      * Initialize manager with bot API and chat ID
      */
@@ -56,6 +63,9 @@ class PinnedMessageManager {
         }
         // Reset changed files for new session
         this.state.changedFiles = [];
+        this.lastRenderedMessageText = null;
+        this.pendingUpdate = false;
+        this.pendingForceUpdate = false;
         // Unpin old message and create new one
         await this.unpinOldMessage();
         await this.createPinnedMessage();
@@ -147,10 +157,30 @@ 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(true);
+    }
     /**
      * Called when cost info is received from SSE events
      */
     async onCostUpdate(cost) {
+        if (!Number.isFinite(cost) || cost === 0) {
+            logger.debug("[PinnedManager] Ignoring non-impacting cost update");
+            return;
+        }
         const currentCost = this.state.cost || 0;
         this.state.cost = currentCost + cost;
         logger.debug(`[PinnedManager] Cost added: $${cost.toFixed(2)}, total session: $${(this.state.cost || 0).toFixed(2)}`);
@@ -162,6 +192,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
@@ -199,6 +235,10 @@ class PinnedMessageManager {
             logger.debug("[PinnedManager] Ignoring empty session.diff, keeping tool-collected data");
             return;
         }
+        if (this.areFileDiffsEqual(this.state.changedFiles, diffs)) {
+            logger.debug("[PinnedManager] Ignoring unchanged session.diff");
+            return;
+        }
         this.state.changedFiles = diffs;
         logger.debug(`[PinnedManager] Session diff updated: ${diffs.length} files`);
         await this.updatePinnedMessage();
@@ -219,15 +259,14 @@ class PinnedMessageManager {
         // Schedule debounced update (avoid spamming Telegram API on rapid tool events)
         this.scheduleDebouncedUpdate();
     }
-    updateDebounceTimer = null;
     scheduleDebouncedUpdate() {
         if (this.updateDebounceTimer) {
             clearTimeout(this.updateDebounceTimer);
         }
         this.updateDebounceTimer = setTimeout(() => {
             this.updateDebounceTimer = null;
-            this.updatePinnedMessage();
-        }, 500);
+            void this.updatePinnedMessage();
+        }, 1000);
     }
     /**
      * Load file diffs from API for current session.
@@ -406,44 +445,34 @@ class PinnedMessageManager {
             return normalized;
         return ".../" + segments.slice(-3).join("/");
     }
+    areFileDiffsEqual(current, next) {
+        if (current.length !== next.length) {
+            return false;
+        }
+        for (let index = 0; index < current.length; index++) {
+            const left = current[index];
+            const right = next[index];
+            if (left.file !== right.file ||
+                left.additions !== right.additions ||
+                left.deletions !== right.deletions) {
+                return false;
+            }
+        }
+        return true;
+    }
     /**
      * Fetch context limit from current model configuration
      */
     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 +480,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 +513,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
      */
@@ -523,6 +528,7 @@ class PinnedMessageManager {
             this.state.messageId = sentMessage.message_id;
             this.state.chatId = this.chatId;
             this.state.lastUpdated = Date.now();
+            this.lastRenderedMessageText = text;
             // Save to settings for persistence
             setPinnedMessageId(sentMessage.message_id);
             // Pin the message (silently)
@@ -538,36 +544,67 @@ class PinnedMessageManager {
     /**
      * Update existing pinned message text
      */
-    async updatePinnedMessage() {
+    async updatePinnedMessage(forceUpdate = false) {
         if (!this.api || !this.chatId || !this.state.messageId) {
             return;
         }
-        try {
-            const text = this.formatMessage();
-            await this.api.editMessageText(this.chatId, this.state.messageId, text);
-            this.state.lastUpdated = Date.now();
-            logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
-            // Trigger keyboard update callback
-            if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
-                setImmediate(() => {
-                    this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
-                });
-            }
+        this.pendingUpdate = true;
+        if (forceUpdate) {
+            this.pendingForceUpdate = true;
         }
-        catch (err) {
-            // Handle "message is not modified" error silently
-            if (err instanceof Error && err.message.includes("message is not modified")) {
+        if (this.updateTask) {
+            await this.updateTask;
+            return;
+        }
+        this.updateTask = this.flushPendingPinnedUpdates().finally(() => {
+            this.updateTask = null;
+        });
+        await this.updateTask;
+    }
+    async flushPendingPinnedUpdates() {
+        while (this.pendingUpdate) {
+            this.pendingUpdate = false;
+            const shouldForceUpdate = this.pendingForceUpdate;
+            this.pendingForceUpdate = false;
+            if (!this.api || !this.chatId || !this.state.messageId) {
                 return;
             }
-            // Handle "message to edit not found" - recreate
-            if (err instanceof Error && err.message.includes("message to edit not found")) {
-                logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
-                this.state.messageId = null;
-                clearPinnedMessageId();
-                await this.createPinnedMessage();
-                return;
+            const text = this.formatMessage();
+            if (!shouldForceUpdate && text === this.lastRenderedMessageText) {
+                logger.debug("[PinnedManager] Skipping pinned update: message content unchanged");
+                continue;
+            }
+            try {
+                await this.api.editMessageText(this.chatId, this.state.messageId, text);
+                this.state.lastUpdated = Date.now();
+                this.lastRenderedMessageText = text;
+                logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
+                // Trigger keyboard update callback
+                if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
+                    setImmediate(() => {
+                        this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
+                    });
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+                // Handle "message is not modified" error silently
+                if (errorMessage.includes("message is not modified")) {
+                    this.lastRenderedMessageText = text;
+                    continue;
+                }
+                // Handle "message to edit not found" - recreate
+                if (errorMessage.includes("message to edit not found")) {
+                    logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
+                    this.state.messageId = null;
+                    this.lastRenderedMessageText = null;
+                    this.pendingForceUpdate = false;
+                    clearPinnedMessageId();
+                    await this.createPinnedMessage();
+                    continue;
+                }
+                logger.error("[PinnedManager] Error updating pinned message:", err);
             }
-            logger.error("[PinnedManager] Error updating pinned message:", err);
         }
     }
     /**
@@ -581,6 +618,9 @@ class PinnedMessageManager {
             // Unpin all messages (ensures clean state)
             await this.api.unpinAllChatMessages(this.chatId).catch(() => { });
             this.state.messageId = null;
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.debug("[PinnedManager] Unpinned old messages");
         }
@@ -611,6 +651,9 @@ class PinnedMessageManager {
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             return;
         }
@@ -625,6 +668,9 @@ class PinnedMessageManager {
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.info("[PinnedManager] Cleared pinned message state");
         }