opencode-telegram-bot 1.0.10 → 1.1.0

package/README.md

@@ -112,6 +112,8 @@ These are handled directly by the Telegram bot:
 | `/model` | Show current model and usage hints |
 | `/model <keyword>` | Search models by keyword |
 | `/model default` | Reset to the default model |
+| `/agent` | Show current agent and switch (plan, build, ...) |
+| `/agent <name>` | Switch directly to a named agent |
 | `/usage` | Show token and cost usage for this session |
 | `/help` | Show available commands |
 
@@ -177,6 +179,33 @@ Other commands:
 - `/model` shows the current model and usage hints
 - `/model default` resets to the server default
 
+### Agent Switching
+
+OpenCode supports multiple agents: **build** (default, full edit access), **plan** (read-only analysis), and others. Use `/agent` to see and switch between them:
+
+```
+You:  /agent
+Bot:  Current agent: build
+
+      Available agents:
+      - build (active) -- The default agent
+      - plan -- Plan mode. Disallows all edit tools.
+      - general -- General-purpose agent
+      - explore -- Codebase explorer
+
+      [build]  [plan]  [general]  [explore]
+
+You:  [tap "plan"]
+      (button message is deleted)
+Bot:  Agent: plan | Model: claude-opus-4 | Verbose: off     [pinned]
+```
+
+### Pinned Status Message
+
+A pinned message at the top of the chat shows the current agent, model, and verbose mode. It updates automatically when any of these change — via `/agent`, `/model`, or `/verbose`. The pinned message is the only confirmation; no separate reply is sent.
+
+Agent, model, and verbose selections are per-chat and persist across bot restarts.
+
 ## Usage
 
 Use `/usage` to see the current session's token counts and estimated cost:

package/dist/app.d.ts

@@ -26,6 +26,9 @@ interface OpencodeClientLike {
         reply: (params: any, options?: any) => Promise<any>;
         reject: (params: any, options?: any) => Promise<any>;
     };
+    app: {
+        agents: (params?: any, options?: any) => Promise<any>;
+    };
 }
 interface StartOptions {
     url: string;
@@ -48,7 +51,7 @@ interface TelegramBot {
     }) => Promise<void>;
     stop: (reason?: string) => void;
     telegram: {
-        sendMessage: (chatId: number, text: string, options?: Record<string, unknown>) => Promise<void>;
+        sendMessage: (chatId: number, text: string, options?: Record<string, unknown>) => Promise<any>;
         deleteMessage: (chatId: number, messageId: number) => Promise<void>;
         sendDocument: (chatId: number, file: {
             source: Buffer;
@@ -61,6 +64,9 @@ interface TelegramBot {
             command: string;
             description: string;
         }>) => Promise<unknown>;
+        pinChatMessage: (chatId: number, messageId: number, extra?: Record<string, unknown>) => Promise<void>;
+        unpinChatMessage: (chatId: number, messageId?: number) => Promise<void>;
+        editMessageText: (chatId: number | undefined, messageId: number | undefined, inlineMessageId: string | undefined, text: string, extra?: Record<string, unknown>) => Promise<void>;
     };
 }
 export declare function startTelegram(options: StartOptions): Promise<TelegramBot>;

package/dist/index.js

@@ -19967,6 +19967,8 @@ async function startTelegram(options) {
     const sessionsFile = options.sessionsFilePath || SESSIONS_FILE;
     // Initialize OpenCode client
     const client = options.client || client_createOpencodeClient({ baseUrl: url });
+    // Available agents fetched from OpenCode on startup
+    let availableAgents = [];
     // Verify connection to the OpenCode server and fetch available commands
     const opencodeCommands = new Set();
     const opencodeCommandMenu = [];
@@ -20004,13 +20006,25 @@ async function startTelegram(options) {
             }
             console.log(`[Telegram] Available OpenCode commands: ${[...opencodeCommands].join(", ")}`);
         }
+        // Fetch available agents
+        const agentsResult = await client.app.agents({});
+        if (agentsResult.data) {
+            availableAgents = agentsResult.data
+                .filter((a) => !a.hidden)
+                .map((a) => ({
+                name: a.name,
+                description: a.description || "",
+                mode: a.mode || "primary",
+            }));
+            console.log(`[Telegram] Available agents: ${availableAgents.map((a) => `${a.name} (${a.mode})`).join(", ")}`);
+        }
     }
     catch (err) {
         throw new Error(`[Telegram] Failed to connect to OpenCode server at ${url}. Make sure it's running (npm run serve). Error: ${err}`);
     }
     // Telegram-only commands that should not be forwarded to OpenCode
     const telegramCommands = new Set([
-        "start", "help", "new", "sessions", "switch", "title", "delete", "export", "verbose", "model", "usage",
+        "start", "help", "new", "sessions", "switch", "title", "delete", "export", "verbose", "model", "usage", "agent",
     ]);
     const telegramCommandMenu = [
         { command: "new", description: "Start a new conversation" },
@@ -20019,6 +20033,7 @@ async function startTelegram(options) {
         { command: "export", description: "Export session (/export full for details)" },
         { command: "verbose", description: "Toggle verbose mode" },
         { command: "model", description: "Search models (/model <keyword>)" },
+        { command: "agent", description: "Switch agent (plan, build, ...)" },
         { command: "usage", description: "Show token and cost usage" },
         { command: "help", description: "Show available commands" },
     ];
@@ -20031,6 +20046,10 @@ async function startTelegram(options) {
     const chatVerboseMode = new Set();
     // Map of chatId -> model override (provider/model)
     const chatModelOverride = new Map();
+    // Map of chatId -> agent override (e.g. "plan", "build")
+    const chatAgentOverride = new Map();
+    // Map of chatId -> pinned status message ID
+    const chatPinnedStatusMsg = new Map();
     // Map of chatId -> last search results (in-memory only)
     const chatModelSearchResults = new Map();
     // Map of questionId -> pending question context (for forwarding OpenCode questions to Telegram)
@@ -20045,6 +20064,8 @@ async function startTelegram(options) {
                 known: [...knownSessionIds],
                 verbose: [...chatVerboseMode],
                 models: Object.fromEntries(chatModelOverride),
+                agents: Object.fromEntries(chatAgentOverride),
+                pinnedStatus: Object.fromEntries(chatPinnedStatusMsg),
             };
             (0,external_node_fs_.writeFileSync)(sessionsFile, JSON.stringify(data, null, 2));
         }
@@ -20062,6 +20083,8 @@ async function startTelegram(options) {
         let storedKnown = [];
         let storedVerbose = [];
         let storedModels = {};
+        let storedAgents = {};
+        let storedPinnedStatus = {};
         if ((0,external_node_fs_.existsSync)(sessionsFile)) {
             try {
                 const raw = (0,external_node_fs_.readFileSync)(sessionsFile, "utf-8");
@@ -20072,6 +20095,8 @@ async function startTelegram(options) {
                     storedKnown = parsed.known || [];
                     storedVerbose = parsed.verbose || [];
                     storedModels = parsed.models || {};
+                    storedAgents = parsed.agents || {};
+                    storedPinnedStatus = parsed.pinnedStatus || {};
                 }
                 else {
                     // Old format: flat { chatId: sessionId }
@@ -20096,6 +20121,18 @@ async function startTelegram(options) {
                 chatModelOverride.set(chatId, modelId);
             }
         }
+        // Restore agent overrides
+        for (const [chatId, agentName] of Object.entries(storedAgents)) {
+            if (agentName) {
+                chatAgentOverride.set(chatId, agentName);
+            }
+        }
+        // Restore pinned status message IDs
+        for (const [chatId, msgId] of Object.entries(storedPinnedStatus)) {
+            if (msgId) {
+                chatPinnedStatusMsg.set(chatId, msgId);
+            }
+        }
         // Fetch all server sessions once for validation and fallback matching
         let serverSessions = [];
         try {
@@ -20214,6 +20251,10 @@ async function startTelegram(options) {
             const modelID = modelParts.join("/");
             promptBody.model = { providerID, modelID };
         }
+        const agentOverride = chatAgentOverride.get(chatId);
+        if (agentOverride) {
+            promptBody.agent = agentOverride;
+        }
         return promptBody;
     }
     function getChatIdFromContext(ctx) {
@@ -20787,7 +20828,12 @@ async function startTelegram(options) {
         if (!authorizedUserId) {
             return next();
         }
-        const userId = ctx.from?.id.toString();
+        // Skip auth for service messages without a sender or from the bot itself
+        // (e.g. pin notifications where ctx.from is the bot)
+        if (!ctx.from || ctx.from.is_bot) {
+            return next();
+        }
+        const userId = ctx.from.id.toString();
         if (userId === authorizedUserId) {
             return next();
         }
@@ -20810,6 +20856,7 @@ async function startTelegram(options) {
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
             "/model <keyword> - Search available models\n" +
+            "/agent - Switch agent (plan, build, ...)\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
         const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
@@ -20832,6 +20879,7 @@ async function startTelegram(options) {
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
             "/model <keyword> - Search available models\n" +
+            "/agent - Switch agent (plan, build, ...)\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
         const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
@@ -21084,9 +21132,7 @@ async function startTelegram(options) {
         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.");
+        updatePinnedStatus(chatId, ctx.chat.id);
     });
     /**
      * Fetch and search available models from connected providers.
@@ -21186,7 +21232,15 @@ async function startTelegram(options) {
         const value = `${selection.providerID}/${selection.modelID}`;
         chatModelOverride.set(chatId, value);
         saveSessions();
-        await answerAndEdit(ctx, `Switched to ${selection.displayName}`);
+        try {
+            await ctx.answerCbQuery();
+        }
+        catch { /* ignore */ }
+        try {
+            await ctx.deleteMessage();
+        }
+        catch { /* ignore */ }
+        updatePinnedStatus(chatId, Number(chatId));
     });
     bot.action("model_default", async (ctx) => {
         const chatId = getChatIdFromContext(ctx);
@@ -21194,7 +21248,144 @@ async function startTelegram(options) {
             return;
         chatModelOverride.delete(chatId);
         saveSessions();
-        await answerAndEdit(ctx, "Model reset to the default model.");
+        try {
+            await ctx.answerCbQuery();
+        }
+        catch { /* ignore */ }
+        try {
+            await ctx.deleteMessage();
+        }
+        catch { /* ignore */ }
+        updatePinnedStatus(chatId, Number(chatId));
+    });
+    // --- Agent switching and pinned status message ---
+    function getActiveAgent(chatId) {
+        return chatAgentOverride.get(chatId) || "build";
+    }
+    function getActiveModelDisplay(chatId) {
+        const m = chatModelOverride.get(chatId) || model;
+        if (!m)
+            return "default";
+        const parts = m.split("/");
+        return parts.length > 1 ? parts.slice(1).join("/") : m;
+    }
+    function buildStatusText(chatId) {
+        const agent = getActiveAgent(chatId);
+        const modelDisplay = getActiveModelDisplay(chatId);
+        const verbose = chatVerboseMode.has(chatId) ? "on" : "off";
+        return `Agent: *${agent}* | Model: ${modelDisplay} | Verbose: ${verbose}`;
+    }
+    function buildStatusKeyboard(chatId) {
+        const active = getActiveAgent(chatId);
+        // Show non-hidden agents as buttons, highlight the active one
+        const buttons = availableAgents
+            .filter((a) => a.mode === "primary" || a.mode === "subagent")
+            .map((a) => ({
+            text: a.name === active ? `[${a.name}]` : a.name,
+            callback_data: `agent:${a.name}`,
+        }));
+        // Arrange in rows of 3
+        const keyboard = [];
+        for (let i = 0; i < buttons.length; i += 3) {
+            keyboard.push(buttons.slice(i, i + 3));
+        }
+        return keyboard;
+    }
+    async function updatePinnedStatus(chatId, numericChatId) {
+        const text = buildStatusText(chatId);
+        // Delete the old status message to keep the chat clean
+        const existingMsgId = chatPinnedStatusMsg.get(chatId);
+        if (existingMsgId) {
+            try {
+                await bot.telegram.deleteMessage(numericChatId, existingMsgId);
+            }
+            catch {
+                // Already deleted
+            }
+            chatPinnedStatusMsg.delete(chatId);
+        }
+        // Always send a fresh message and pin it. Editing in place doesn't
+        // refresh the pinned bar on Android, so delete+send+pin is the only
+        // reliable approach. The pinned message itself serves as the
+        // confirmation — no separate reply is needed.
+        try {
+            const msg = await bot.telegram.sendMessage(numericChatId, text, {
+                parse_mode: "Markdown",
+            });
+            const messageId = msg.message_id;
+            if (messageId) {
+                chatPinnedStatusMsg.set(chatId, messageId);
+                saveSessions();
+                try {
+                    await bot.telegram.pinChatMessage(numericChatId, messageId, {
+                        disable_notification: true,
+                    });
+                }
+                catch (pinErr) {
+                    console.warn("[Telegram] Failed to pin status message:", pinErr);
+                }
+            }
+        }
+        catch (err) {
+            console.warn("[Telegram] Failed to send status message:", err);
+        }
+    }
+    // Handle /agent command
+    bot.command("agent", async (ctx) => {
+        const chatId = ctx.chat.id.toString();
+        const args = (ctx.message?.text || "").replace(/^\/agent\s*/i, "").trim();
+        if (!args) {
+            // Show current agent and list available ones
+            const current = getActiveAgent(chatId);
+            let msg = `Current agent: *${current}*\n\nAvailable agents:\n`;
+            for (const a of availableAgents) {
+                const marker = a.name === current ? " (active)" : "";
+                const desc = a.description ? ` -- ${truncate(a.description, 80)}` : "";
+                msg += `- *${a.name}*${marker}${desc}\n`;
+            }
+            msg += "\nTap a button or use `/agent <name>` to switch.";
+            const keyboard = buildStatusKeyboard(chatId);
+            await ctx.reply(msg, {
+                parse_mode: "Markdown",
+                reply_markup: { inline_keyboard: keyboard },
+            });
+            return;
+        }
+        // Direct switch by name
+        const target = args.toLowerCase();
+        const match = availableAgents.find((a) => a.name === target);
+        if (!match) {
+            await ctx.reply(`Unknown agent "${args}". Available: ${availableAgents.map((a) => a.name).join(", ")}`);
+            return;
+        }
+        chatAgentOverride.set(chatId, match.name);
+        saveSessions();
+        await updatePinnedStatus(chatId, ctx.chat.id);
+    });
+    // Handle agent switch via inline button
+    bot.action(/^agent:(.+)$/, async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        if (!chatId)
+            return;
+        const agentName = ctx.match?.[1];
+        if (!agentName)
+            return;
+        const match = availableAgents.find((a) => a.name === agentName);
+        if (!match) {
+            await answerAndEdit(ctx, `Unknown agent: ${agentName}`);
+            return;
+        }
+        chatAgentOverride.set(chatId, match.name);
+        saveSessions();
+        try {
+            await ctx.answerCbQuery();
+        }
+        catch { /* ignore */ }
+        try {
+            await ctx.deleteMessage();
+        }
+        catch { /* ignore */ }
+        await updatePinnedStatus(chatId, Number(chatId));
     });
     // Handle question answer callback (from OpenCode question.asked events)
     bot.action(/^qa:([^:]+):(\d+):(\d+)$/, async (ctx) => {

package/package.json

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