@grinev/opencode-telegram-bot 0.12.0 → 0.13.0

package/dist/pinned/manager.js

@@ -17,6 +17,7 @@ class PinnedMessageManager {
         tokensLimit: 0,
         lastUpdated: 0,
         changedFiles: [],
+        cost: 0,
     };
     contextLimit = null;
     onKeyboardUpdateCallback;
@@ -40,6 +41,7 @@ class PinnedMessageManager {
         logger.info(`[PinnedManager] Session changed: ${sessionId}, title: ${sessionTitle}`);
         // Reset tokens for new session
         this.state.tokensUsed = 0;
+        this.state.cost = 0;
         // Update state
         this.state.sessionId = sessionId;
         this.state.sessionTitle = sessionTitle || t("pinned.default_session_title");
@@ -84,9 +86,10 @@ class PinnedMessageManager {
                 logger.warn("[PinnedManager] Failed to load session history:", error);
                 return;
             }
-            // Get the maximum context size from session history
+            // Get the maximum context size and total cost from session history
             // Context = input + cache.read (cache.read contains previously cached context)
             let maxContextSize = 0;
+            let totalCost = 0;
             logger.debug(`[PinnedManager] Processing ${messagesData.length} messages from history`);
             messagesData.forEach(({ info }) => {
                 if (info.role === "assistant") {
@@ -99,16 +102,20 @@ class PinnedMessageManager {
                     const input = assistantInfo.tokens?.input || 0;
                     const cacheRead = assistantInfo.tokens?.cache?.read || 0;
                     const contextSize = input + cacheRead;
-                    logger.debug(`[PinnedManager] Assistant message: input=${input}, cache.read=${cacheRead}, total=${contextSize}`);
+                    const cost = assistantInfo.cost || 0;
+                    logger.debug(`[PinnedManager] Assistant message: input=${input}, cache.read=${cacheRead}, total=${contextSize}, cost=$${cost.toFixed(2)}`);
                     // Keep track of maximum context size (peak usage in session)
                     if (contextSize > maxContextSize) {
                         maxContextSize = contextSize;
                     }
+                    // Accumulate total session cost
+                    totalCost += cost;
                 }
             });
             this.state.tokensUsed = maxContextSize;
+            this.state.cost = totalCost;
             this.state.sessionId = sessionId;
-            logger.info(`[PinnedManager] Loaded context from history: ${this.state.tokensUsed} tokens`);
+            logger.info(`[PinnedManager] Loaded context from history: ${this.state.tokensUsed} tokens, cost: $${this.state.cost.toFixed(2)}`);
             await this.updatePinnedMessage();
         }
         catch (err) {
@@ -140,6 +147,15 @@ class PinnedMessageManager {
         await this.refreshSessionTitle();
         await this.updatePinnedMessage();
     }
+    /**
+     * Called when cost info is received from SSE events
+     */
+    async onCostUpdate(cost) {
+        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)}`);
+        await this.updatePinnedMessage();
+    }
     /**
      * Set callback for keyboard updates when context changes
      */
@@ -455,6 +471,9 @@ class PinnedMessageManager {
                 percent: percentage,
             }),
         ];
+        if (this.state.cost !== undefined && this.state.cost !== null) {
+            lines.push(t("pinned.line.cost", { cost: `$${this.state.cost.toFixed(2)}` }));
+        }
         if (this.state.changedFiles.length > 0) {
             const maxFiles = 10;
             const total = this.state.changedFiles.length;

package/dist/summary/aggregator.js

@@ -26,18 +26,19 @@ function countDiffChangesFromText(text) {
 }
 class SummaryAggregator {
     currentSessionId = null;
-    currentMessageParts = new Map();
-    pendingParts = new Map();
+    textMessageStates = new Map();
     messages = new Map();
     messageCount = 0;
     lastUpdated = 0;
     onCompleteCallback = null;
+    onPartialCallback = null;
     onToolCallback = null;
     onToolFileCallback = null;
     onQuestionCallback = null;
     onQuestionErrorCallback = null;
     onThinkingCallback = null;
     onTokensCallback = null;
+    onCostCallback = null;
     onSessionCompactedCallback = null;
     onSessionErrorCallback = null;
     onSessionRetryCallback = null;
@@ -47,9 +48,11 @@ class SummaryAggregator {
     onClearedCallback = null;
     processedToolStates = new Set();
     thinkingFiredForMessages = new Set();
+    knownTextPartIds = new Map();
     bot = null;
     chatId = null;
     typingTimer = null;
+    typingIndicatorEnabled = true;
     partHashes = new Map();
     setBotAndChatId(bot, chatId) {
         this.bot = bot;
@@ -58,6 +61,9 @@ class SummaryAggregator {
     setOnComplete(callback) {
         this.onCompleteCallback = callback;
     }
+    setOnPartial(callback) {
+        this.onPartialCallback = callback;
+    }
     setOnTool(callback) {
         this.onToolCallback = callback;
     }
@@ -76,6 +82,9 @@ class SummaryAggregator {
     setOnTokens(callback) {
         this.onTokensCallback = callback;
     }
+    setOnCost(callback) {
+        this.onCostCallback = callback;
+    }
     setOnSessionCompacted(callback) {
         this.onSessionCompactedCallback = callback;
     }
@@ -97,7 +106,16 @@ class SummaryAggregator {
     setOnCleared(callback) {
         this.onClearedCallback = callback;
     }
+    setTypingIndicatorEnabled(enabled) {
+        this.typingIndicatorEnabled = enabled;
+        if (!enabled) {
+            this.stopTypingIndicator();
+        }
+    }
     startTypingIndicator() {
+        if (!this.typingIndicatorEnabled) {
+            return;
+        }
         if (this.typingTimer) {
             return;
         }
@@ -118,6 +136,11 @@ class SummaryAggregator {
         }
     }
     processEvent(event) {
+        const eventType = event.type;
+        if (eventType === "message.part.delta") {
+            this.handleMessagePartDelta(event);
+            return;
+        }
         // Log all question-related events for debugging
         if (event.type.startsWith("question.")) {
             logger.info(`[Aggregator] Question event: ${event.type}`, JSON.stringify(event.properties, null, 2));
@@ -177,10 +200,10 @@ class SummaryAggregator {
     clear() {
         this.stopTypingIndicator();
         this.currentSessionId = null;
-        this.currentMessageParts.clear();
-        this.pendingParts.clear();
+        this.textMessageStates.clear();
         this.messages.clear();
         this.partHashes.clear();
+        this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
         this.messageCount = 0;
@@ -202,21 +225,26 @@ class SummaryAggregator {
         const messageID = info.id;
         this.messages.set(messageID, { role: info.role });
         if (info.role === "assistant") {
-            if (!this.currentMessageParts.has(messageID)) {
-                this.currentMessageParts.set(messageID, []);
+            if (!this.textMessageStates.has(messageID)) {
+                this.textMessageStates.set(messageID, {
+                    orderedPartIds: [],
+                    partTexts: new Map(),
+                    optimisticUpdateCount: 0,
+                });
                 this.messageCount++;
                 this.startTypingIndicator();
             }
-            const pending = this.pendingParts.get(messageID) || [];
-            const current = this.currentMessageParts.get(messageID) || [];
-            this.currentMessageParts.set(messageID, [...current, ...pending]);
-            this.pendingParts.delete(messageID);
+            const textState = this.getOrCreateTextMessageState(messageID);
             const assistantMessage = info;
             const time = assistantMessage.time;
-            if (time?.completed) {
-                const parts = this.currentMessageParts.get(messageID) || [];
-                const lastPart = parts[parts.length - 1] || "";
-                logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${lastPart.length}, totalParts=${parts.length}, session=${this.currentSessionId}`);
+            const isCompleted = Boolean(time?.completed);
+            const messageText = this.getCombinedMessageText(messageID);
+            if (!isCompleted && textState.optimisticUpdateCount === 1) {
+                this.emitPartialText(info.sessionID, messageID, messageText);
+            }
+            if (isCompleted) {
+                const finalText = messageText;
+                logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${finalText.length}, totalParts=${textState.orderedPartIds.length}, session=${this.currentSessionId}`);
                 // Extract and report tokens BEFORE onComplete so keyboard context is updated
                 const assistantInfo = info;
                 if (this.onTokensCallback && assistantInfo.tokens) {
@@ -231,14 +259,20 @@ class SummaryAggregator {
                     // Call synchronously so keyboardManager is updated before onComplete sends the reply
                     this.onTokensCallback(tokens);
                 }
-                if (this.onCompleteCallback && lastPart.length > 0) {
-                    this.onCompleteCallback(this.currentSessionId, lastPart);
+                // Extract and report cost
+                if (this.onCostCallback && assistantInfo.cost !== undefined) {
+                    logger.debug(`[Aggregator] Cost: $${assistantInfo.cost.toFixed(2)}`);
+                    this.onCostCallback(assistantInfo.cost);
+                }
+                if (this.onCompleteCallback && finalText.length > 0) {
+                    this.onCompleteCallback(this.currentSessionId, messageID, finalText);
                 }
-                this.currentMessageParts.delete(messageID);
+                this.textMessageStates.delete(messageID);
                 this.messages.delete(messageID);
                 this.partHashes.delete(messageID);
-                logger.debug(`[Aggregator] Message completed cleanup: remaining messages=${this.currentMessageParts.size}`);
-                if (this.currentMessageParts.size === 0) {
+                this.knownTextPartIds.delete(messageID);
+                logger.debug(`[Aggregator] Message completed cleanup: remaining messages=${this.textMessageStates.size}`);
+                if (this.textMessageStates.size === 0) {
                     logger.debug("[Aggregator] No more active messages, stopping typing indicator");
                     this.stopTypingIndicator();
                 }
@@ -253,6 +287,18 @@ class SummaryAggregator {
         }
         const messageID = part.messageID;
         const messageInfo = this.messages.get(messageID);
+        if (part.type === "text") {
+            this.registerKnownTextPart(messageID, part.id);
+            this.registerTextPart(messageID, part.id);
+        }
+        const deltaFromUpdated = event.properties.delta;
+        if (part.type === "text" &&
+            typeof deltaFromUpdated === "string" &&
+            deltaFromUpdated.length > 0) {
+            this.applyTextDelta(part.sessionID, messageID, part.id, deltaFromUpdated, part.text);
+            this.lastUpdated = Date.now();
+            return;
+        }
         if (part.type === "reasoning") {
             // Fire the thinking callback once per message on the first reasoning part.
             // This is the signal that the model is actually doing extended thinking.
@@ -268,29 +314,23 @@ class SummaryAggregator {
             }
         }
         else if (part.type === "text" && "text" in part && part.text) {
-            const partHash = this.hashString(part.text);
-            if (!this.partHashes.has(messageID)) {
-                this.partHashes.set(messageID, new Set());
-            }
-            const hashes = this.partHashes.get(messageID);
-            if (hashes.has(partHash)) {
+            const wasUpdated = messageInfo && messageInfo.role === "assistant"
+                ? this.setTextPartSnapshot(messageID, part.id, part.text)
+                : this.setOptimisticTextSnapshot(messageID, part.id, part.text);
+            if (!wasUpdated) {
                 return;
             }
-            hashes.add(partHash);
+            const fullText = this.getCombinedMessageText(messageID);
             if (messageInfo && messageInfo.role === "assistant") {
-                if (!this.currentMessageParts.has(messageID)) {
-                    this.currentMessageParts.set(messageID, []);
-                    this.startTypingIndicator();
-                }
-                const parts = this.currentMessageParts.get(messageID);
-                parts.push(part.text);
+                this.startTypingIndicator();
+                this.emitPartialText(part.sessionID, messageID, fullText);
             }
             else {
-                if (!this.pendingParts.has(messageID)) {
-                    this.pendingParts.set(messageID, []);
+                const state = this.getOrCreateTextMessageState(messageID);
+                state.optimisticUpdateCount++;
+                if (state.optimisticUpdateCount >= 2) {
+                    this.emitPartialText(part.sessionID, messageID, fullText);
                 }
-                const pending = this.pendingParts.get(messageID);
-                pending.push(part.text);
             }
         }
         else if (part.type === "tool") {
@@ -351,6 +391,125 @@ class SummaryAggregator {
         }
         this.lastUpdated = Date.now();
     }
+    handleMessagePartDelta(event) {
+        const part = event.properties.part;
+        const sessionID = part?.sessionID || event.properties.sessionID;
+        const messageID = part?.messageID || event.properties.messageID;
+        const partID = part?.id || event.properties.partID || "text";
+        const partType = part?.type || event.properties.type;
+        const delta = event.properties.delta;
+        if (!sessionID || !messageID || typeof delta !== "string" || delta.length === 0) {
+            return;
+        }
+        if (partType && partType !== "text") {
+            return;
+        }
+        if (partType === "text") {
+            this.registerKnownTextPart(messageID, partID);
+            this.registerTextPart(messageID, partID);
+        }
+        else {
+            const knownTextIds = this.knownTextPartIds.get(messageID);
+            const isKnownTextPart = knownTextIds?.has(partID) ?? false;
+            const thinkingFired = this.thinkingFiredForMessages.has(messageID);
+            if (thinkingFired && !isKnownTextPart) {
+                return;
+            }
+            if (!thinkingFired && !isKnownTextPart) {
+                this.registerKnownTextPart(messageID, partID);
+                this.registerTextPart(messageID, partID);
+            }
+        }
+        this.applyTextDelta(sessionID, messageID, partID, delta, part?.text);
+    }
+    applyTextDelta(sessionID, messageID, partID, delta, fullTextHint) {
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        this.registerTextPart(messageID, partID);
+        const state = this.getOrCreateTextMessageState(messageID);
+        const previous = state.partTexts.get(partID) || "";
+        let accumulated = `${previous}${delta}`;
+        if (typeof fullTextHint === "string" && fullTextHint.length > accumulated.length) {
+            accumulated = fullTextHint;
+        }
+        state.partTexts.set(partID, accumulated);
+        const combined = this.getCombinedMessageText(messageID);
+        if (!combined.trim()) {
+            return;
+        }
+        this.startTypingIndicator();
+        this.emitPartialText(sessionID, messageID, combined);
+    }
+    emitPartialText(sessionId, messageId, messageText) {
+        if (!this.onPartialCallback || !messageText.trim()) {
+            return;
+        }
+        try {
+            this.onPartialCallback(sessionId, messageId, messageText);
+        }
+        catch (err) {
+            logger.error("[Aggregator] Error in partial callback:", err);
+        }
+    }
+    getOrCreateTextMessageState(messageID) {
+        const existing = this.textMessageStates.get(messageID);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            orderedPartIds: [],
+            partTexts: new Map(),
+            optimisticUpdateCount: 0,
+        };
+        this.textMessageStates.set(messageID, state);
+        return state;
+    }
+    registerKnownTextPart(messageID, partID) {
+        if (!this.knownTextPartIds.has(messageID)) {
+            this.knownTextPartIds.set(messageID, new Set());
+        }
+        this.knownTextPartIds.get(messageID).add(partID);
+    }
+    registerTextPart(messageID, partID) {
+        const state = this.getOrCreateTextMessageState(messageID);
+        if (!state.orderedPartIds.includes(partID)) {
+            state.orderedPartIds.push(partID);
+        }
+    }
+    setTextPartSnapshot(messageID, partID, text) {
+        const normalized = text;
+        const partHash = this.hashString(`${partID}\n${normalized}`);
+        if (!this.partHashes.has(messageID)) {
+            this.partHashes.set(messageID, new Set());
+        }
+        const hashes = this.partHashes.get(messageID);
+        if (hashes.has(partHash)) {
+            return false;
+        }
+        hashes.add(partHash);
+        this.registerTextPart(messageID, partID);
+        const state = this.getOrCreateTextMessageState(messageID);
+        state.partTexts.set(partID, normalized);
+        return true;
+    }
+    setOptimisticTextSnapshot(messageID, partID, text) {
+        const wasUpdated = this.setTextPartSnapshot(messageID, partID, text);
+        if (!wasUpdated) {
+            return false;
+        }
+        const state = this.getOrCreateTextMessageState(messageID);
+        state.orderedPartIds = [partID];
+        state.partTexts = new Map([[partID, text]]);
+        return true;
+    }
+    getCombinedMessageText(messageID) {
+        const state = this.textMessageStates.get(messageID);
+        if (!state) {
+            return "";
+        }
+        return state.orderedPartIds.map((partID) => state.partTexts.get(partID) || "").join("");
+    }
     prepareToolFileContext(tool, input, title, metadata) {
         if (tool === "write" && input) {
             const filePath = typeof input.filePath === "string" ? normalizePathForDisplay(input.filePath) : "";

package/dist/summary/formatter.js

@@ -144,11 +144,13 @@ function formatMarkdownForTelegram(text) {
         return text;
     }
 }
-export function formatSummaryWithMode(text, mode) {
+export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_LIMIT) {
     if (!text || text.trim().length === 0) {
         return [];
     }
-    const parts = splitText(text, TELEGRAM_MESSAGE_LIMIT);
+    const normalizedMaxLength = Math.max(1, Math.floor(maxLength));
+    const rawTextLimit = mode === "raw" ? Math.max(1, normalizedMaxLength - "```\n\n```".length) : normalizedMaxLength;
+    const parts = splitText(text, rawTextLimit);
     const formattedParts = [];
     for (const part of parts) {
         const trimmed = part.trim();
@@ -157,7 +159,7 @@ export function formatSummaryWithMode(text, mode) {
         }
         if (mode === "markdown") {
             const converted = formatMarkdownForTelegram(trimmed);
-            const convertedParts = splitText(converted, TELEGRAM_MESSAGE_LIMIT);
+            const convertedParts = splitText(converted, normalizedMaxLength);
             for (const convertedPart of convertedParts) {
                 const normalizedPart = convertedPart.trim();
                 if (normalizedPart) {

package/dist/summary/tool-message-batcher.js

@@ -46,6 +46,15 @@ export class ToolMessageBatcher {
     enqueue(sessionId, message) {
         this.enqueueTextInternal(sessionId, message);
     }
+    sendTextNow(sessionId, message, reason) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        const expectedGeneration = this.generation;
+        logger.debug(`[ToolBatcher] Sending immediate text message outside queue: session=${sessionId}, reason=${reason}`);
+        void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, reason, expectedGeneration));
+    }
     enqueueUniqueByPrefix(sessionId, message, prefix) {
         this.enqueueTextInternal(sessionId, message, prefix);
     }

package/package.json

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