opencode-telegram-bot 1.0.6 → 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+
@@ -111,12 +115,16 @@ These are handled directly by the Telegram bot:
 | `/usage` | Show token and cost usage for this session |
 | `/help` | Show available commands |
 
+The bot also registers these commands in Telegram's command menu (the `/` button), plus any OpenCode server commands discovered at startup (excluding hidden ones like `/init` and `/review`).
+
 ### Verbose Mode
 
 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.
 
@@ -128,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...
 ```
 
@@ -217,17 +230,14 @@ Bot:  Your sessions:
       Current session: Fix the broken tests
       Tap a session to switch or delete.
 
-You:  /switch def6
-Bot:  Switched to session: Auth refactoring (def67890)
-
 You:  What were we working on?
 Bot:  [agent responds with context from the auth refactoring session]
 
-You:  /delete abc1
-Bot:  Deleted session: Fix the broken tests (abc12345)
+You:  [tap "Auth refactoring"]
+Bot:  Switched to session: Auth refactoring
 ```
 
-The `/sessions` list only shows sessions created by the Telegram bot, not sessions from other OpenCode clients (like the TUI). You cannot delete the currently active session -- use `/new` or `/switch` first.
+The `/sessions` list only shows sessions created by the Telegram bot, not sessions from other OpenCode clients (like the TUI). You cannot delete the currently active session -- use `/new` first.
 
 ## Session Persistence
 

package/dist/app.d.ts

@@ -49,6 +49,10 @@ interface TelegramBot {
         getFileLink: (fileId: string) => Promise<{
             toString(): string;
         }>;
+        setMyCommands: (commands: Array<{
+            command: string;
+            description: string;
+        }>) => Promise<unknown>;
     };
 }
 export declare function startTelegram(options: StartOptions): Promise<TelegramBot>;

package/dist/index.js

@@ -18589,6 +18589,9 @@ async function startTelegram(options) {
     const client = options.client || client_createOpencodeClient({ baseUrl: url });
     // Verify connection to the OpenCode server and fetch available commands
     const opencodeCommands = new Set();
+    const opencodeCommandMenu = [];
+    const hiddenOpenCodeCommands = new Set(["init", "review", "reviews"]);
+    const isHiddenOpenCodeCommand = (name) => hiddenOpenCodeCommands.has(name.toLowerCase());
     let projectDirectory = "";
     try {
         const sessions = await client.session.list();
@@ -18606,7 +18609,16 @@ async function startTelegram(options) {
         const cmds = await client.command.list();
         if (cmds.data) {
             for (const cmd of cmds.data) {
-                opencodeCommands.add(cmd.name);
+                const name = cmd.name;
+                if (!name)
+                    continue;
+                opencodeCommands.add(name);
+                if (!isHiddenOpenCodeCommand(name)) {
+                    opencodeCommandMenu.push({
+                        command: name,
+                        description: cmd.description || "OpenCode command",
+                    });
+                }
             }
             console.log(`[Telegram] Available OpenCode commands: ${[...opencodeCommands].join(", ")}`);
         }
@@ -18618,6 +18630,17 @@ async function startTelegram(options) {
     const telegramCommands = new Set([
         "start", "help", "new", "sessions", "switch", "title", "delete", "export", "verbose", "model", "usage",
     ]);
+    const telegramCommandMenu = [
+        { command: "new", description: "Start a new conversation" },
+        { command: "sessions", description: "List your sessions" },
+        { command: "title", description: "Rename a session (/title <text>)" },
+        { command: "export", description: "Export session (/export full for details)" },
+        { command: "verbose", description: "Toggle verbose mode" },
+        { command: "model", description: "Search models (/model <keyword>)" },
+        { command: "usage", description: "Show token and cost usage" },
+        { command: "help", description: "Show available commands" },
+    ];
+    const getVisibleOpenCodeCommands = () => [...opencodeCommands].filter((command) => !isHiddenOpenCodeCommand(command));
     // Map of chatId -> sessionId for the active session per chat
     const chatSessions = new Map();
     // Set of all session IDs ever created/used by this bot (for filtering)
@@ -18951,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;
@@ -18976,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;
         }
@@ -18985,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) {
@@ -19007,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;
                             }
                         }
                     }
@@ -19053,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);
@@ -19119,6 +19305,25 @@ async function startTelegram(options) {
     const bot = options.botFactory
         ? options.botFactory(token)
         : new lib.Telegraf(token);
+    async function registerCommandMenu() {
+        const combined = [...telegramCommandMenu, ...opencodeCommandMenu];
+        const seen = new Set();
+        const commands = [];
+        for (const entry of combined) {
+            if (!entry.command || seen.has(entry.command))
+                continue;
+            seen.add(entry.command);
+            commands.push(entry);
+        }
+        if (commands.length === 0)
+            return;
+        try {
+            await bot.telegram.setMyCommands(commands);
+        }
+        catch (err) {
+            console.warn("[Telegram] Failed to register command menu:", err);
+        }
+    }
     // Middleware to check if the user is authorized
     bot.use((ctx, next) => {
         if (!authorizedUserId) {
@@ -19134,24 +19339,26 @@ async function startTelegram(options) {
             return;
         }
     });
+    await registerCommandMenu();
     // Handle /start command
     bot.start((ctx) => {
         let msg = "Hello! I'm your OpenCode bot. Send me a message and I'll forward it to the OpenCode agent.\n\n" +
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
-            "/sessions - List your sessions\n" +
+            "/sessions - List your sessions (buttons)\n" +
             "/title <text> - Rename the current session\n" +
             "/export - Export the current session as a markdown file\n" +
             "/export full - Export with all details (thinking, costs, steps)\n" +
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
-            "/model - Show or search available models\n" +
+            "/model <keyword> - Search available models\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
-        if (opencodeCommands.size > 0) {
+        const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
+        if (visibleOpenCodeCommands.length > 0) {
             msg +=
                 "\nOpenCode commands are also available:\n" +
-                    [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                    visibleOpenCodeCommands.map((c) => `/${c}`).join(", ");
         }
         ctx.reply(msg);
     });
@@ -19160,19 +19367,20 @@ async function startTelegram(options) {
         let msg = "Send me any message and I'll process it using OpenCode.\n\n" +
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
-            "/sessions - List your sessions\n" +
+            "/sessions - List your sessions (buttons)\n" +
             "/title <text> - Rename the current session\n" +
             "/export - Export the current session as a markdown file\n" +
             "/export full - Export with all details (thinking, costs, steps)\n" +
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
-            "/model - Show or search available models\n" +
+            "/model <keyword> - Search available models\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
-        if (opencodeCommands.size > 0) {
+        const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
+        if (visibleOpenCodeCommands.length > 0) {
             msg +=
                 "\nOpenCode commands:\n" +
-                    [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                    visibleOpenCodeCommands.map((c) => `/${c}`).join(", ");
         }
         ctx.reply(msg);
     });
@@ -19842,7 +20050,9 @@ async function startTelegram(options) {
             }
             // Check if it's a known OpenCode command
             if (!opencodeCommands.has(commandName)) {
-                const available = [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                const available = getVisibleOpenCodeCommands()
+                    .map((c) => `/${c}`)
+                    .join(", ");
                 await ctx.reply(`Unknown command: /${commandName}\n\n` +
                     `Available OpenCode commands: ${available || "none"}\n` +
                     `Bot commands: /new, /help`);

package/package.json

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