opencode-telegram-bot 1.0.1 → 1.0.3

package/README.md

@@ -103,8 +103,43 @@ These are handled directly by the Telegram bot:
 | `/switch <id>` | Switch to a different session (prefix match supported) |
 | `/title <text>` | Rename the current session |
 | `/delete <id>` | Delete a session from the server |
+| `/export` | Export the current session as a markdown file |
+| `/export full` | Export with all details (thinking, costs, steps) |
+| `/verbose` | Toggle verbose mode (show thinking and tool calls in chat) |
+| `/verbose on|off` | Explicitly enable/disable verbose mode |
 | `/help` | Show available commands |
 
+### 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`)
+
+Verbose mode is per-chat and persists across bot restarts. Use `/verbose` again to turn it off.
+
+Example with verbose mode on:
+
+```
+🧠 Thinking: Let me analyze the authentication flow and check for potential issues...
+
+⚙️ grep -- pattern: "authenticate" in src/
+⚙️ read -- src/auth/handler.ts
+
+Here's what I found in the auth module...
+```
+
+### Session Export
+
+The `/export` command builds a markdown file from the current session and saves it to the directory where OpenCode is running. The file is also sent back to you as a Telegram document.
+
+Two modes are available:
+
+- **`/export`** -- Default. Includes user messages, assistant text, and tool calls (name, input, output).
+- **`/export full`** (also accepts `detailed` or `all`) -- Includes everything from the default mode plus reasoning/thinking blocks, step boundaries with token counts, costs, subtasks, retries, and compaction markers.
+
+The exported file is named `session-<id>.md` (or `session-<id>-detailed.md` for the full export).
+
 ### OpenCode Commands
 
 Any `/` command that isn't a bot command is automatically forwarded to the OpenCode server via its command system. The bot fetches the list of available commands on startup and validates them.

package/dist/index.js

@@ -18588,12 +18588,19 @@ async function startTelegram(options) {
     const client = client_createOpencodeClient({ baseUrl: url });
     // Verify connection to the OpenCode server and fetch available commands
     const opencodeCommands = new Set();
+    let projectDirectory = "";
     try {
         const sessions = await client.session.list();
         if (sessions.error) {
             throw new Error(`Server returned error: ${JSON.stringify(sessions.error)}`);
         }
         console.log(`[Telegram] Connected to OpenCode server at ${url}`);
+        // Fetch the project directory (needed for SSE event subscription)
+        const pathResult = await client.path.get();
+        if (pathResult.data?.directory) {
+            projectDirectory = pathResult.data.directory;
+            console.log(`[Telegram] Project directory: ${projectDirectory}`);
+        }
         // Fetch available OpenCode commands
         const cmds = await client.command.list();
         if (cmds.data) {
@@ -18608,12 +18615,14 @@ async function startTelegram(options) {
     }
     // Telegram-only commands that should not be forwarded to OpenCode
     const telegramCommands = new Set([
-        "start", "help", "new", "sessions", "switch", "title", "delete",
+        "start", "help", "new", "sessions", "switch", "title", "delete", "export", "verbose",
     ]);
     // 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)
     const knownSessionIds = new Set();
+    // Set of chatIds with verbose mode enabled
+    const chatVerboseMode = new Set();
     /**
      * Save the chat-to-session mapping and known session IDs to disk.
      */
@@ -18622,6 +18631,7 @@ async function startTelegram(options) {
             const data = {
                 active: Object.fromEntries(chatSessions),
                 known: [...knownSessionIds],
+                verbose: [...chatVerboseMode],
             };
             (0,external_node_fs_.writeFileSync)(SESSIONS_FILE, JSON.stringify(data, null, 2));
         }
@@ -18637,14 +18647,16 @@ async function startTelegram(options) {
         // Load from file (supports both old flat format and new {active, known} format)
         let storedActive = {};
         let storedKnown = [];
+        let storedVerbose = [];
         if ((0,external_node_fs_.existsSync)(SESSIONS_FILE)) {
             try {
                 const raw = (0,external_node_fs_.readFileSync)(SESSIONS_FILE, "utf-8");
                 const parsed = JSON.parse(raw);
                 if (parsed.active && typeof parsed.active === "object") {
-                    // New format: { active: {...}, known: [...] }
+                    // New format: { active: {...}, known: [...], verbose: [...] }
                     storedActive = parsed.active;
                     storedKnown = parsed.known || [];
+                    storedVerbose = parsed.verbose || [];
                 }
                 else {
                     // Old format: flat { chatId: sessionId }
@@ -18656,6 +18668,13 @@ async function startTelegram(options) {
                 console.warn("[Telegram] Failed to parse sessions file:", err);
             }
         }
+        // Restore verbose mode preferences
+        for (const chatId of storedVerbose) {
+            chatVerboseMode.add(chatId);
+        }
+        if (storedVerbose.length > 0) {
+            console.log(`[Telegram] Restored verbose mode for ${storedVerbose.length} chat(s)`);
+        }
         // Fetch all server sessions once for validation and fallback matching
         let serverSessions = [];
         try {
@@ -18758,6 +18777,52 @@ async function startTelegram(options) {
             console.warn("[Telegram] Failed to auto-title session:", err);
         }
     }
+    /**
+     * Build a one-line summary for a tool call, picking the most meaningful input field.
+     */
+    function summarizeTool(tool, input) {
+        if (!input)
+            return tool;
+        // Pick the most descriptive field based on common tool patterns
+        const summaryField = input.filePath || input.path || input.command || input.pattern ||
+            input.url || input.query || input.content || input.prompt ||
+            input.description || input.name;
+        if (summaryField && typeof summaryField === "string") {
+            return `${tool} -- ${truncate(summaryField, 80)}`;
+        }
+        // For tools with a glob/include pattern
+        if (input.include && typeof input.include === "string") {
+            return `${tool} -- ${truncate(input.include, 80)}`;
+        }
+        return tool;
+    }
+    /**
+     * Send a message to Telegram, with Markdown fallback.
+     * When disableLinkPreview is true, link previews are suppressed (useful for verbose messages).
+     */
+    async function sendTelegramMessage(chatId, text, disableLinkPreview = false) {
+        const options = {
+            parse_mode: "Markdown",
+        };
+        if (disableLinkPreview) {
+            options.link_preview_options = { is_disabled: true };
+        }
+        try {
+            await bot.telegram.sendMessage(chatId, text, options);
+        }
+        catch {
+            try {
+                const fallbackOptions = {};
+                if (disableLinkPreview) {
+                    fallbackOptions.link_preview_options = { is_disabled: true };
+                }
+                await bot.telegram.sendMessage(chatId, text, fallbackOptions);
+            }
+            catch (fallbackErr) {
+                console.error("[Telegram] Fallback error:", fallbackErr);
+            }
+        }
+    }
     /**
      * Extract text from response parts and send to Telegram chat.
      */
@@ -18781,20 +18846,145 @@ async function startTelegram(options) {
         // Send the response, splitting if needed (Telegram has a 4096 char limit)
         const chunks = splitMessage(responseText, 4096);
         for (const chunk of chunks) {
-            try {
-                await bot.telegram.sendMessage(chatId, chunk, {
-                    parse_mode: "Markdown",
-                });
-            }
-            catch {
+            await sendTelegramMessage(chatId, chunk);
+        }
+    }
+    /**
+     * Send a prompt with streaming: fires the prompt asynchronously, then listens
+     * to SSE events to stream thinking and tool call updates to Telegram in real-time.
+     * The final text response is sent when the session goes idle.
+     */
+    async function sendPromptStreaming(chatId, sessionId, promptBody, processingMsgId, verbose = false) {
+        // Subscribe to SSE events before sending the prompt so we don't miss anything
+        const abortController = new AbortController();
+        // Subscribe to SSE events before sending the prompt so we don't miss anything
+        const subscribeOptions = {
+            signal: abortController.signal,
+        };
+        if (projectDirectory) {
+            subscribeOptions.query = { directory: projectDirectory };
+        }
+        const { stream } = await client.event.subscribe(subscribeOptions);
+        // Fire the prompt asynchronously (returns immediately)
+        const asyncResult = await client.session.promptAsync({
+            path: { id: sessionId },
+            body: promptBody,
+        });
+        if (asyncResult.error) {
+            abortController.abort();
+            throw new Error(`Prompt failed: ${JSON.stringify(asyncResult.error)}`);
+        }
+        // Track state as events stream in
+        let finalText = "";
+        let processingMsgDeleted = false;
+        const sentToolIds = new Set();
+        const sentReasoningIds = new Set();
+        // 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;
+        /**
+         * Delete the "processing" message once, right before sending the first real output.
+         */
+        async function deleteProcessingMsg() {
+            if (!processingMsgDeleted) {
+                processingMsgDeleted = true;
                 try {
-                    await bot.telegram.sendMessage(chatId, chunk);
+                    await bot.telegram.deleteMessage(chatId, processingMsgId);
                 }
-                catch (fallbackErr) {
-                    console.error("[Telegram] Fallback error:", fallbackErr);
+                catch {
+                    // Ignore
                 }
             }
         }
+        /**
+         * Flush any buffered reasoning to Telegram as a spoiler message.
+         */
+        async function flushReasoning() {
+            if (verbose && pendingReasoning && !sentReasoningIds.has(pendingReasoning.id)) {
+                sentReasoningIds.add(pendingReasoning.id);
+                await deleteProcessingMsg();
+                const truncated = truncate(pendingReasoning.text.replace(/\n/g, " "), 500);
+                await sendTelegramMessage(chatId, `\u{1F9E0} Thinking: ${truncated}`, true);
+            }
+            pendingReasoning = null;
+        }
+        try {
+            for await (const event of stream) {
+                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)
+                        continue;
+                    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 };
+                        }
+                    }
+                    else if (part.type === "tool" && part.id) {
+                        // A tool part arrived -- flush any pending reasoning first
+                        await flushReasoning();
+                        if (verbose) {
+                            const state = part.state;
+                            // Only send tool messages once they have a completed/error status
+                            if (state &&
+                                (state.status === "completed" || state.status === "error") &&
+                                !sentToolIds.has(part.id)) {
+                                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}`;
+                                }
+                                await sendTelegramMessage(chatId, line, true);
+                            }
+                        }
+                    }
+                    else if (part.type === "text") {
+                        // A text part arrived -- flush any pending reasoning first
+                        await flushReasoning();
+                        // Accumulate text for the final response (text parts carry the full text, not deltas)
+                        const text = part.text;
+                        if (text) {
+                            finalText = text;
+                        }
+                    }
+                }
+                else if (ev.type === "session.idle" && ev.properties) {
+                    const idleSessionId = ev.properties.sessionID;
+                    if (idleSessionId === sessionId) {
+                        // Flush any remaining reasoning before finishing
+                        await flushReasoning();
+                        break;
+                    }
+                }
+                else if (ev.type === "session.error" && ev.properties) {
+                    const errorSessionId = ev.properties.sessionID;
+                    if (errorSessionId === sessionId) {
+                        const error = ev.properties.error;
+                        const errorMsg = error?.data?.message || "Unknown error";
+                        throw new Error(`Session error: ${errorMsg}`);
+                    }
+                }
+            }
+        }
+        finally {
+            abortController.abort();
+        }
+        // Delete the processing message if it hasn't been deleted yet (non-verbose mode)
+        await deleteProcessingMsg();
+        // Send the final text response
+        if (!finalText) {
+            finalText = "The agent returned an empty response.";
+        }
+        const chunks = splitMessage(finalText, 4096);
+        for (const chunk of chunks) {
+            await sendTelegramMessage(chatId, chunk);
+        }
     }
     /**
      * Handle session errors - clear invalid sessions.
@@ -18845,6 +19035,10 @@ async function startTelegram(options) {
             "/switch <number> - Switch to a different session\n" +
             "/title <text> - Rename the current session\n" +
             "/delete <number> - Delete a 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" +
             "/help - Show this help message\n";
         if (opencodeCommands.size > 0) {
             msg +=
@@ -18862,6 +19056,10 @@ async function startTelegram(options) {
             "/switch <number> - Switch to a different session\n" +
             "/title <text> - Rename the current session\n" +
             "/delete <number> - Delete a 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" +
             "/help - Show this help message\n";
         if (opencodeCommands.size > 0) {
             msg +=
@@ -19021,6 +19219,260 @@ async function startTelegram(options) {
             await ctx.reply("Failed to delete session.");
         }
     });
+    // Handle /verbose command - toggle verbose mode for this chat
+    // Usage: /verbose, /verbose on, /verbose off
+    bot.command("verbose", (ctx) => {
+        const chatId = ctx.chat.id.toString();
+        const args = ctx.message.text.replace(/^\/verbose\s*/, "").trim().toLowerCase();
+        if (args === "on") {
+            chatVerboseMode.add(chatId);
+        }
+        else if (args === "off") {
+            chatVerboseMode.delete(chatId);
+        }
+        else {
+            if (chatVerboseMode.has(chatId)) {
+                chatVerboseMode.delete(chatId);
+            }
+            else {
+                chatVerboseMode.add(chatId);
+            }
+        }
+        saveSessions();
+        const enabled = chatVerboseMode.has(chatId);
+        console.log(`[Telegram] Verbose mode ${enabled ? "enabled" : "disabled"} for chat ${chatId}`);
+        ctx.reply(enabled
+            ? "Verbose mode enabled. Responses will include thinking and tool calls."
+            : "Verbose mode disabled. Responses will only show the assistant's text.");
+    });
+    /**
+     * Render a message part to markdown.
+     * In default mode: only text and tool calls (name + input/output).
+     * In detailed mode: also includes reasoning, step info, subtasks, costs, etc.
+     */
+    function renderPart(part, detailed) {
+        let md = "";
+        switch (part.type) {
+            case "text": {
+                const text = part.text;
+                if (text) {
+                    md += `${text}\n\n`;
+                }
+                break;
+            }
+            case "tool": {
+                const tool = part.tool;
+                const state = part.state;
+                md += `**Tool: ${tool}**\n\n`;
+                if (state.input) {
+                    md += `**Input:**\n\`\`\`json\n${JSON.stringify(state.input, null, 2)}\n\`\`\`\n\n`;
+                }
+                if (state.output) {
+                    md += `**Output:**\n\`\`\`\n${state.output}\n\`\`\`\n\n`;
+                }
+                if (state.error) {
+                    md += `**Error:**\n\`\`\`\n${state.error}\n\`\`\`\n\n`;
+                }
+                if (detailed && state.time) {
+                    const duration = ((state.time.end - state.time.start) / 1000).toFixed(1);
+                    md += `*Status: ${state.status} (${duration}s)*\n\n`;
+                }
+                break;
+            }
+            case "reasoning": {
+                if (!detailed)
+                    break;
+                const text = part.text;
+                if (text) {
+                    md += `<details>\n<summary>Thinking</summary>\n\n${text}\n\n</details>\n\n`;
+                }
+                break;
+            }
+            case "step-start": {
+                if (!detailed)
+                    break;
+                md += `---\n*Step started*\n\n`;
+                break;
+            }
+            case "step-finish": {
+                if (!detailed)
+                    break;
+                const reason = part.reason;
+                const cost = part.cost;
+                const tokens = part.tokens;
+                let info = `*Step finished`;
+                if (reason)
+                    info += ` (${reason})`;
+                info += `*`;
+                if (tokens) {
+                    info += `\n*Tokens: ${tokens.input} in / ${tokens.output} out`;
+                    if (tokens.reasoning > 0)
+                        info += ` / ${tokens.reasoning} reasoning`;
+                    if (tokens.cache.read > 0 || tokens.cache.write > 0) {
+                        info += ` (cache: ${tokens.cache.read} read, ${tokens.cache.write} write)`;
+                    }
+                    info += `*`;
+                }
+                if (cost !== undefined && cost > 0) {
+                    info += `\n*Cost: $${cost.toFixed(4)}*`;
+                }
+                md += `${info}\n\n---\n\n`;
+                break;
+            }
+            case "subtask": {
+                if (!detailed)
+                    break;
+                const description = part.description;
+                const agent = part.agent;
+                const prompt = part.prompt;
+                md += `**Subtask${agent ? ` (${agent})` : ""}**`;
+                if (description)
+                    md += `: ${description}`;
+                md += `\n\n`;
+                if (prompt) {
+                    md += `> ${prompt.replace(/\n/g, "\n> ")}\n\n`;
+                }
+                break;
+            }
+            case "agent": {
+                if (!detailed)
+                    break;
+                const name = part.name;
+                if (name) {
+                    md += `*Agent: ${name}*\n\n`;
+                }
+                break;
+            }
+            case "retry": {
+                if (!detailed)
+                    break;
+                const attempt = part.attempt;
+                const error = part.error;
+                md += `**Retry (attempt ${attempt || "?"})**`;
+                if (error?.data?.message) {
+                    md += `\n\`\`\`\n${error.data.message}\n\`\`\``;
+                }
+                md += `\n\n`;
+                break;
+            }
+            case "compaction": {
+                if (!detailed)
+                    break;
+                const auto = part.auto;
+                md += `*Context compacted${auto ? " (auto)" : ""}*\n\n`;
+                break;
+            }
+            default:
+                // snapshot, patch, file, etc. - skip in both modes
+                break;
+        }
+        return md;
+    }
+    // Handle /export command - export the current session to the opencode project directory
+    // Usage: /export        - default (text + tool calls only)
+    //        /export full   - detailed (includes thinking, steps, costs, subtasks, etc.)
+    bot.command("export", async (ctx) => {
+        const chatId = ctx.chat.id.toString();
+        const sessionId = chatSessions.get(chatId);
+        if (!sessionId) {
+            await ctx.reply("No active session. Send a message first to create one.");
+            return;
+        }
+        const args = ctx.message.text.replace(/^\/export\s*/, "").trim().toLowerCase();
+        const detailed = args === "full" || args === "detailed" || args === "all";
+        try {
+            const modeLabel = detailed ? "detailed" : "summary";
+            const processingMsg = await ctx.reply(`Exporting session (${modeLabel})...`);
+            // Fetch session info and messages in parallel
+            const [sessionResult, messagesResult, pathResult] = await Promise.all([
+                client.session.get({ path: { id: sessionId } }),
+                client.session.messages({ path: { id: sessionId } }),
+                client.path.get(),
+            ]);
+            if (sessionResult.error || !sessionResult.data) {
+                throw new Error(`Failed to get session: ${JSON.stringify(sessionResult.error)}`);
+            }
+            if (messagesResult.error || !messagesResult.data) {
+                throw new Error(`Failed to get messages: ${JSON.stringify(messagesResult.error)}`);
+            }
+            const session = sessionResult.data;
+            const messages = messagesResult.data;
+            // Build the markdown export
+            let md = `# ${session.title}\n\n`;
+            md += `**Session ID:** ${session.id}\n`;
+            md += `**Created:** ${new Date(session.time.created * 1000).toLocaleString()}\n`;
+            md += `**Updated:** ${new Date(session.time.updated * 1000).toLocaleString()}\n`;
+            if (detailed) {
+                md += `**Export mode:** Detailed\n`;
+            }
+            md += `\n---\n\n`;
+            for (const msg of messages) {
+                const info = msg.info;
+                const parts = msg.parts || [];
+                if (info.role === "user") {
+                    md += `## User\n\n`;
+                    for (const part of parts) {
+                        md += renderPart(part, detailed);
+                    }
+                    md += `---\n\n`;
+                }
+                else if (info.role === "assistant") {
+                    const assistant = info;
+                    const duration = assistant.time.completed
+                        ? ((assistant.time.completed - assistant.time.created) / 1000).toFixed(1) + "s"
+                        : "";
+                    const modelLabel = assistant.modelID || "unknown";
+                    const modeLabel = assistant.mode || "";
+                    const header = [modeLabel, modelLabel, duration].filter(Boolean).join(" · ");
+                    md += `## Assistant (${header})\n\n`;
+                    if (detailed && assistant.tokens) {
+                        const t = assistant.tokens;
+                        md += `*Tokens: ${t.input} in / ${t.output} out`;
+                        if (t.reasoning > 0)
+                            md += ` / ${t.reasoning} reasoning`;
+                        if (t.cache.read > 0 || t.cache.write > 0) {
+                            md += ` (cache: ${t.cache.read} read, ${t.cache.write} write)`;
+                        }
+                        md += `*\n`;
+                        if (assistant.cost && assistant.cost > 0) {
+                            md += `*Cost: $${assistant.cost.toFixed(4)}*\n`;
+                        }
+                        md += `\n`;
+                    }
+                    for (const part of parts) {
+                        md += renderPart(part, detailed);
+                    }
+                    md += `---\n\n`;
+                }
+            }
+            // Write to the project directory
+            const projectDir = pathResult.data?.directory;
+            const idPrefix = sessionId.substring(0, 8);
+            const suffix = detailed ? "-detailed" : "";
+            const filename = `session-${idPrefix}${suffix}.md`;
+            const exportPath = (0,external_node_path_.resolve)(projectDir || ".", filename);
+            (0,external_node_fs_.writeFileSync)(exportPath, md, "utf-8");
+            console.log(`[Telegram] Exported session ${sessionId} to ${exportPath} (${detailed ? "detailed" : "summary"})`);
+            // Delete the processing message
+            try {
+                await bot.telegram.deleteMessage(ctx.chat.id, processingMsg.message_id);
+            }
+            catch {
+                // Ignore if we can't delete it
+            }
+            // Send the file to the user
+            await bot.telegram.sendDocument(ctx.chat.id, {
+                source: Buffer.from(md, "utf-8"),
+                filename,
+            });
+            await ctx.reply(`Session exported to: ${exportPath}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error exporting session:", err);
+            await handleSessionError(chatId);
+            await ctx.reply("Sorry, there was an error exporting the session. Try again or use /new to start a fresh session.");
+        }
+    });
     // Catch-all for unregistered / commands - forward to OpenCode
     bot.on("text", async (ctx) => {
         const userText = ctx.message.text;
@@ -19052,6 +19504,7 @@ async function startTelegram(options) {
                     body: {
                         command: commandName,
                         arguments: commandArgs,
+                        agent: "default",
                     },
                 });
                 if (result.error) {
@@ -19083,15 +19536,8 @@ async function startTelegram(options) {
                 const modelID = modelParts.join("/");
                 promptBody.model = { providerID, modelID };
             }
-            const result = await client.session.prompt({
-                path: { id: sessionId },
-                body: promptBody,
-            });
-            if (result.error) {
-                throw new Error(`Prompt failed: ${JSON.stringify(result.error)}`);
-            }
-            const parts = (result.data?.parts || []);
-            await sendResponseToChat(ctx.chat.id, parts, processingMsg.message_id);
+            const verbose = chatVerboseMode.has(chatId);
+            await sendPromptStreaming(ctx.chat.id, sessionId, promptBody, processingMsg.message_id, verbose);
         }
         catch (err) {
             console.error("[Telegram] Error processing message:", err);

package/package.json

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