@grinev/opencode-telegram-bot 0.6.1 → 0.8.0

package/dist/model/capabilities.js

@@ -0,0 +1,62 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const capabilitiesCache = {};
+/**
+ * Get model capabilities from OpenCode API
+ * Results are cached in memory per model
+ */
+export async function getModelCapabilities(providerID, modelID) {
+    const cacheKey = `${providerID}/${modelID}`;
+    if (capabilitiesCache[cacheKey] !== undefined) {
+        logger.debug(`[ModelCapabilities] Cache hit for ${cacheKey}`);
+        return capabilitiesCache[cacheKey];
+    }
+    try {
+        logger.debug(`[ModelCapabilities] Fetching capabilities for ${cacheKey}`);
+        const response = await opencodeClient.config.providers();
+        if (response.error || !response.data) {
+            logger.error("[ModelCapabilities] API returned error:", response.error);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const providers = response.data.providers;
+        const provider = providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[ModelCapabilities] Provider ${providerID} not found`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[ModelCapabilities] Model ${cacheKey} not found in provider`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        logger.debug(`[ModelCapabilities] Found capabilities for ${cacheKey}`);
+        capabilitiesCache[cacheKey] = model.capabilities;
+        return model.capabilities;
+    }
+    catch (error) {
+        logger.error("[ModelCapabilities] Failed to fetch providers:", error);
+        capabilitiesCache[cacheKey] = null;
+        return null;
+    }
+}
+/**
+ * Check if model supports a specific input type
+ */
+export function supportsInput(capabilities, inputType) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.input[inputType] === true;
+}
+/**
+ * Check if model supports attachments in general
+ */
+export function supportsAttachment(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.attachment === true;
+}

package/dist/stt/client.js

@@ -0,0 +1,64 @@
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+const STT_REQUEST_TIMEOUT_MS = 60_000;
+/**
+ * Returns true if STT is configured (API URL and API key are set).
+ */
+export function isSttConfigured() {
+    return Boolean(config.stt.apiUrl && config.stt.apiKey);
+}
+/**
+ * Transcribes an audio buffer using a Whisper-compatible API (OpenAI / Groq / etc.).
+ *
+ * Sends a multipart/form-data POST to `{STT_API_URL}/audio/transcriptions`.
+ *
+ * @param audioBuffer - Raw audio file bytes (ogg, mp3, wav, m4a, webm, etc.)
+ * @param filename    - Original filename with extension (used by the API to detect format)
+ * @returns Transcribed text
+ * @throws Error if STT is not configured, the request fails, or the response is invalid
+ */
+export async function transcribeAudio(audioBuffer, filename) {
+    if (!isSttConfigured()) {
+        throw new Error("STT is not configured: STT_API_URL and STT_API_KEY are required");
+    }
+    const url = `${config.stt.apiUrl}/audio/transcriptions`;
+    const formData = new FormData();
+    formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
+    formData.append("model", config.stt.model);
+    formData.append("response_format", "json");
+    if (config.stt.language) {
+        formData.append("language", config.stt.language);
+    }
+    logger.debug(`[STT] Sending transcription request: url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), STT_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.stt.apiKey}`,
+            },
+            body: formData,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            throw new Error(`STT API returned HTTP ${response.status}: ${errorBody || response.statusText}`);
+        }
+        const data = (await response.json());
+        if (typeof data.text !== "string") {
+            throw new Error("STT API response does not contain a text field");
+        }
+        logger.debug(`[STT] Transcription result: ${data.text.length} chars`);
+        return { text: data.text };
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+            throw new Error(`STT request timed out after ${STT_REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/summary/aggregator.js

@@ -39,11 +39,13 @@ class SummaryAggregator {
     onThinkingCallback = null;
     onTokensCallback = null;
     onSessionCompactedCallback = null;
+    onSessionErrorCallback = null;
     onPermissionCallback = null;
     onSessionDiffCallback = null;
     onFileChangeCallback = null;
     onClearedCallback = null;
     processedToolStates = new Set();
+    thinkingFiredForMessages = new Set();
     bot = null;
     chatId = null;
     typingTimer = null;
@@ -76,6 +78,9 @@ class SummaryAggregator {
     setOnSessionCompacted(callback) {
         this.onSessionCompactedCallback = callback;
     }
+    setOnSessionError(callback) {
+        this.onSessionErrorCallback = callback;
+    }
     setOnPermission(callback) {
         this.onPermissionCallback = callback;
     }
@@ -133,6 +138,9 @@ class SummaryAggregator {
             case "session.compacted":
                 this.handleSessionCompacted(event);
                 break;
+            case "session.error":
+                this.handleSessionError(event);
+                break;
             case "question.asked":
                 this.handleQuestionAsked(event);
                 break;
@@ -170,6 +178,7 @@ class SummaryAggregator {
         this.messages.clear();
         this.partHashes.clear();
         this.processedToolStates.clear();
+        this.thinkingFiredForMessages.clear();
         this.messageCount = 0;
         this.lastUpdated = 0;
         if (this.onClearedCallback) {
@@ -193,16 +202,6 @@ class SummaryAggregator {
                 this.currentMessageParts.set(messageID, []);
                 this.messageCount++;
                 this.startTypingIndicator();
-                const isSummaryMessage = info.summary === true;
-                // Notify that agent started thinking
-                if (!isSummaryMessage && this.onThinkingCallback) {
-                    const callback = this.onThinkingCallback;
-                    setImmediate(() => {
-                        if (typeof callback === "function") {
-                            callback(info.sessionID);
-                        }
-                    });
-                }
             }
             const pending = this.pendingParts.get(messageID) || [];
             const current = this.currentMessageParts.get(messageID) || [];
@@ -250,7 +249,21 @@ class SummaryAggregator {
         }
         const messageID = part.messageID;
         const messageInfo = this.messages.get(messageID);
-        if (part.type === "text" && "text" in part && part.text) {
+        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.
+            if (!this.thinkingFiredForMessages.has(messageID) && this.onThinkingCallback) {
+                this.thinkingFiredForMessages.add(messageID);
+                const callback = this.onThinkingCallback;
+                const sessionID = part.sessionID;
+                setImmediate(() => {
+                    if (typeof callback === "function") {
+                        callback(sessionID);
+                    }
+                });
+            }
+        }
+        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());
@@ -452,6 +465,21 @@ class SummaryAggregator {
             });
         }
     }
+    handleSessionError(event) {
+        const { sessionID, error } = event.properties;
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
+        logger.warn(`[Aggregator] Session error: ${sessionID}: ${message}`);
+        this.stopTypingIndicator();
+        if (this.onSessionErrorCallback) {
+            const callback = this.onSessionErrorCallback;
+            setImmediate(() => {
+                callback(sessionID, message);
+            });
+        }
+    }
     handleQuestionAsked(event) {
         const { id, sessionID, questions } = event.properties;
         if (sessionID !== this.currentSessionId) {

package/dist/summary/formatter.js

@@ -1,4 +1,5 @@
 import * as path from "path";
+import { convert } from "telegram-markdown-v2";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
@@ -22,6 +23,87 @@ function splitText(text, maxLength) {
     }
     return parts;
 }
+function isCodeFenceLine(line) {
+    return line.trimStart().startsWith("```");
+}
+function isHorizontalRuleLine(line) {
+    const normalized = line.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /^([-*_])(?:\s*\1){2,}$/.test(normalized);
+}
+function isHeadingLine(line) {
+    return /^\s{0,3}#{1,6}\s+\S/.test(line);
+}
+function normalizeHeadingLine(line) {
+    const match = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
+    if (!match) {
+        return line;
+    }
+    return `**${match[1]}**`;
+}
+function normalizeChecklistLine(line) {
+    const match = line.match(/^(\s*)(?:[-+*]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const marker = match[2].toLowerCase() === "x" ? "✅" : "🔲";
+    return `${match[1]}${marker} ${match[3]}`;
+}
+function preprocessMarkdownForTelegram(text) {
+    const lines = text.split("\n");
+    const output = [];
+    let inCodeFence = false;
+    let inQuote = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (isCodeFenceLine(line)) {
+            inCodeFence = !inCodeFence;
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (inCodeFence) {
+            output.push(line);
+            continue;
+        }
+        if (!line.trim()) {
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (isHeadingLine(line)) {
+            output.push(normalizeHeadingLine(line));
+            inQuote = false;
+            continue;
+        }
+        if (isHorizontalRuleLine(line)) {
+            output.push("──────────");
+            inQuote = false;
+            continue;
+        }
+        const trimmedLeft = line.trimStart();
+        if (trimmedLeft.startsWith(">")) {
+            inQuote = true;
+            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
+            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
+            output.push(normalizedChecklistInQuote ? `> ${normalizedChecklistInQuote.trimStart()}` : trimmedLeft);
+            continue;
+        }
+        const normalizedChecklist = normalizeChecklistLine(line);
+        if (normalizedChecklist) {
+            output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
+            continue;
+        }
+        if (inQuote) {
+            output.push(`> ${trimmedLeft}`);
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
 export function normalizePathForDisplay(filePath) {
     const normalizedPath = filePath.replace(/\\/g, "/");
     const project = getCurrentProject();
@@ -44,6 +126,25 @@ export function normalizePathForDisplay(filePath) {
     return normalizedPath;
 }
 export function formatSummary(text) {
+    return formatSummaryWithMode(text, config.bot.messageFormatMode);
+}
+export function getAssistantParseMode() {
+    if (config.bot.messageFormatMode === "markdown") {
+        return "MarkdownV2";
+    }
+    return undefined;
+}
+function formatMarkdownForTelegram(text) {
+    try {
+        const preprocessed = preprocessMarkdownForTelegram(text);
+        return convert(preprocessed, "keep");
+    }
+    catch (error) {
+        logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
+        return text;
+    }
+}
+export function formatSummaryWithMode(text, mode) {
     if (!text || text.trim().length === 0) {
         return [];
     }
@@ -54,6 +155,17 @@ export function formatSummary(text) {
         if (!trimmed) {
             continue;
         }
+        if (mode === "markdown") {
+            const converted = formatMarkdownForTelegram(trimmed);
+            const convertedParts = splitText(converted, TELEGRAM_MESSAGE_LIMIT);
+            for (const convertedPart of convertedParts) {
+                const normalizedPart = convertedPart.trim();
+                if (normalizedPart) {
+                    formattedParts.push(normalizedPart);
+                }
+            }
+            continue;
+        }
         if (parts.length > 1) {
             formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,7 +57,8 @@
     "dotenv": "^17.2.3",
     "grammy": "^1.39.2",
     "https-proxy-agent": "^7.0.6",
-    "socks-proxy-agent": "^8.0.5"
+    "socks-proxy-agent": "^8.0.5",
+    "telegram-markdown-v2": "^0.0.4"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",