opencode-telegram-bot 1.0.7 → 1.0.8

package/README.md

@@ -2,6 +2,10 @@
 
 A Telegram bot that forwards messages to an [OpenCode](https://opencode.ai) agent and returns the responses. Each chat gets a persistent session, so the agent remembers conversation context across messages.
 
+## 🎥 Demo
+
+https://github.com/user-attachments/assets/e071f536-7036-4e9c-a5fb-c77414626825
+
 ## Prerequisites
 
 - [Node.js](https://nodejs.org/) 18+
@@ -118,7 +122,9 @@ The bot also registers these commands in Telegram's command menu (the `/` button
 By default, the bot only shows the assistant's final text response. Use `/verbose` to toggle verbose mode (or `/verbose on|off` to set it explicitly), which also displays:
 
 - **Thinking/reasoning** -- shown as plain text with a 🧠 prefix, truncated to 500 characters
-- **Tool calls** -- shown as a compact one-line summary (e.g. `> read -- src/app.ts`)
+- **Tool calls** -- shown as a compact one-line summary (e.g. `⚙️ read -- src/app.ts`)
+- **Delegations** -- shown when work is delegated to a subagent (e.g. `🧩 Delegated: Find relevant docs`)
+- **Subagent details** -- reasoning/tool calls from subagents when available, plus a short `ℹ️ Subagent responded` notice
 
 Verbose mode is per-chat and persists across bot restarts. Use `/verbose` again to turn it off.
 
@@ -130,6 +136,11 @@ Example with verbose mode on:
 ⚙️ grep -- pattern: "authenticate" in src/
 ⚙️ read -- src/auth/handler.ts
 
+🧩 Delegated: Search auth docs
+🧠 Thinking (agent: subagent): Scanning docs for auth references...
+⚙️ read -- README.md (agent: subagent)
+ℹ️ Subagent responded
+
 Here's what I found in the auth module...
 ```
 

package/dist/index.js

@@ -18974,6 +18974,63 @@ async function startTelegram(options) {
         let processingMsgDeleted = false;
         const sentToolIds = new Set();
         const sentReasoningIds = new Set();
+        const sentSubtaskIds = new Set();
+        let sawDelegation = false;
+        let sentSubagentDetails = false;
+        let sentSubagentResponseNotice = false;
+        function extractTaskId(outputText) {
+            const match = outputText.match(/task[_-]?id:\s*([\w-]+)/i);
+            return match ? match[1] : null;
+        }
+        async function emitSubagentMessages(taskSessionId) {
+            try {
+                const messagesResult = await client.session.messages({
+                    path: { id: taskSessionId },
+                });
+                if (messagesResult.error || !messagesResult.data) {
+                    console.warn(`[Telegram] Failed to fetch subagent messages for ${taskSessionId}: ${JSON.stringify(messagesResult.error)}`);
+                    return;
+                }
+                for (const msg of messagesResult.data) {
+                    const info = msg.info;
+                    if (info?.role !== "assistant")
+                        continue;
+                    const parts = msg.parts || [];
+                    for (const part of parts) {
+                        if (part.type === "reasoning") {
+                            const text = part.text;
+                            if (!text)
+                                continue;
+                            const truncated = truncate(text.replace(/\n/g, " "), 500);
+                            await sendTelegramMessage(chatId, `\u{1F9E0} Thinking (agent: subagent): ${truncated}`, true);
+                            sentSubagentDetails = true;
+                        }
+                        if (part.type === "tool") {
+                            const tool = part.tool;
+                            const state = part.state;
+                            if (!state)
+                                continue;
+                            if (state.status !== "completed" && state.status !== "error")
+                                continue;
+                            const summary = summarizeTool(tool, state.input);
+                            let line = `\u{2699}\u{FE0F} ${summary} (agent: subagent)`;
+                            if (state.status === "error") {
+                                line += ` \u{274C}`;
+                            }
+                            await sendTelegramMessage(chatId, line, true);
+                            sentSubagentDetails = true;
+                        }
+                    }
+                }
+                if (!sentSubagentResponseNotice) {
+                    await sendTelegramMessage(chatId, "ℹ️ Subagent responded", true);
+                    sentSubagentResponseNotice = true;
+                }
+            }
+            catch (err) {
+                console.warn("[Telegram] Error fetching subagent messages:", err);
+            }
+        }
         // Buffer the latest reasoning text -- we send it when a non-reasoning part arrives
         // so we get the complete thinking block rather than a partial one
         let pendingReasoning = null;
@@ -18999,7 +19056,10 @@ async function startTelegram(options) {
                 sentReasoningIds.add(pendingReasoning.id);
                 await deleteProcessingMsg();
                 const truncated = truncate(pendingReasoning.text.replace(/\n/g, " "), 500);
-                await sendTelegramMessage(chatId, `\u{1F9E0} Thinking: ${truncated}`, true);
+                const agentLabel = pendingReasoning.agent
+                    ? ` (agent: ${pendingReasoning.agent})`
+                    : "";
+                await sendTelegramMessage(chatId, `\u{1F9E0} Thinking${agentLabel}: ${truncated}`, true);
             }
             pendingReasoning = null;
         }
@@ -19008,14 +19068,26 @@ async function startTelegram(options) {
                 const ev = event;
                 if (ev.type === "message.part.updated" && ev.properties) {
                     const part = ev.properties.part;
-                    // Only process events for our session
-                    if (part.sessionID !== sessionId)
+                    const partSessionId = part.sessionID;
+                    const parentSessionId = part.parentSessionID ||
+                        part.parentSessionId;
+                    const rootSessionId = part.rootSessionID ||
+                        part.rootSessionId;
+                    const isPrimarySession = partSessionId === sessionId;
+                    const isChildSession = parentSessionId === sessionId || rootSessionId === sessionId;
+                    // Only process events for our session (or subagent sessions that link back)
+                    if (!isPrimarySession && !isChildSession)
                         continue;
+                    if (!isPrimarySession && isChildSession && verbose) {
+                        // Subagent events are allowed to stream in verbose mode
+                    }
                     const partText = part.text;
                     if (part.type === "reasoning" && part.id) {
                         // Buffer reasoning -- keep updating with the latest full text
                         if (partText) {
-                            pendingReasoning = { id: part.id, text: partText };
+                            const agent = part.agent ||
+                                (!isPrimarySession ? "subagent" : undefined);
+                            pendingReasoning = { id: part.id, text: partText, agent };
                         }
                     }
                     else if (part.type === "tool" && part.id) {
@@ -19030,12 +19102,74 @@ async function startTelegram(options) {
                                 sentToolIds.add(part.id);
                                 await deleteProcessingMsg();
                                 const tool = part.tool;
-                                const summary = summarizeTool(tool, state.input);
-                                let line = `\u{2699}\u{FE0F} ${summary}`;
-                                if (state.status === "error") {
-                                    line += ` \u{274C}`;
+                                const agent = part.agent ||
+                                    (!isPrimarySession ? "subagent" : undefined);
+                                if (tool === "task") {
+                                    const input = state.input;
+                                    const description = input?.description || input?.prompt || summarizeTool(tool, state.input);
+                                    let line = `\u{1F9E9} Delegated`;
+                                    if (description) {
+                                        line += `: ${truncate(description, 120)}`;
+                                    }
+                                    if (agent) {
+                                        line += ` (agent: ${agent})`;
+                                    }
+                                    if (state.status === "error") {
+                                        line += ` \u{274C}`;
+                                    }
+                                    await sendTelegramMessage(chatId, line, true);
+                                    sawDelegation = true;
+                                    if (state.output && verbose) {
+                                        const rawOutput = typeof state.output === "string"
+                                            ? state.output
+                                            : JSON.stringify(state.output, null, 2);
+                                        const outputText = rawOutput.trim();
+                                        if (outputText) {
+                                            const taskSessionId = extractTaskId(outputText);
+                                            if (taskSessionId) {
+                                                await emitSubagentMessages(taskSessionId);
+                                            }
+                                            if (!sentSubagentDetails && !sentSubagentResponseNotice) {
+                                                await sendTelegramMessage(chatId, "ℹ️ Subagent responded (no thought/tool details available)", true);
+                                                sentSubagentResponseNotice = true;
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    const summary = summarizeTool(tool, state.input);
+                                    let line = `\u{2699}\u{FE0F} ${summary}`;
+                                    if (agent) {
+                                        line += ` (agent: ${agent})`;
+                                    }
+                                    if (state.status === "error") {
+                                        line += ` \u{274C}`;
+                                    }
+                                    await sendTelegramMessage(chatId, line, true);
+                                }
+                            }
+                        }
+                    }
+                    else if (part.type === "subtask") {
+                        await flushReasoning();
+                        if (verbose) {
+                            const id = part.id;
+                            if (!id || !sentSubtaskIds.has(id)) {
+                                if (id)
+                                    sentSubtaskIds.add(id);
+                                await deleteProcessingMsg();
+                                const description = part.description;
+                                const agent = part.agent ||
+                                    (!isPrimarySession ? "subagent" : undefined);
+                                let line = "\u{1F9E9} Delegated";
+                                if (description) {
+                                    line += `: ${truncate(description, 120)}`;
+                                }
+                                if (agent) {
+                                    line += ` (agent: ${agent})`;
                                 }
                                 await sendTelegramMessage(chatId, line, true);
+                                sawDelegation = true;
                             }
                         }
                     }
@@ -19076,6 +19210,35 @@ async function startTelegram(options) {
         if (!finalText) {
             finalText = "The agent returned an empty response.";
         }
+        if (verbose && sawDelegation) {
+            const lines = finalText.split("\n");
+            let inTaskResult = false;
+            const filtered = lines.filter((line) => {
+                const trimmed = line.trim();
+                if (/^<task_result>$/i.test(trimmed)) {
+                    inTaskResult = true;
+                    return false;
+                }
+                if (/^<\/task_result>$/i.test(trimmed)) {
+                    inTaskResult = false;
+                    return false;
+                }
+                if (inTaskResult)
+                    return false;
+                if (/^Subagent response:/i.test(trimmed))
+                    return false;
+                if (/^Subagent (ran|returned|reported)/i.test(trimmed))
+                    return false;
+                if (/^Ran the subagent/i.test(trimmed))
+                    return false;
+                return true;
+            });
+            const cleaned = filtered.join("\n").trim();
+            if (!cleaned) {
+                return;
+            }
+            finalText = cleaned;
+        }
         const chunks = splitMessage(finalText, 4096);
         for (const chunk of chunks) {
             await sendTelegramMessage(chatId, chunk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-telegram-bot",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "type": "module",
   "description": "Telegram bot that forwards messages to an OpenCode agent",
   "main": "./dist/index.js",