open-agents-ai 0.187.583 → 0.187.584

package/README.md

@@ -3365,7 +3365,7 @@ All settings commands accept `--local` to save to project `.oa/settings.json` in
 
 `/platforms menu` opens a keyboard-driven connectivity surface for platform status and onboarding. The same surface is available through `/gateway menu`.
 
-Supported adapter IDs are `telegram`, `discord`, `slack`, `matrix`, and `webhook`. Telegram is wired into the existing bridge controls, so the menu can save the bot token, save the admin user ID, start the bridge, stop it, and show status. The other platform adapters expose the shared connector configuration surface: enable/disable, token environment variable, base URL or webhook URL, default target/channel/room, polling vs webhook mode, redacted config display, and status/health reporting.
+Supported adapter IDs are `telegram`, `discord`, `slack`, `matrix`, and `webhook`. Telegram is wired into the existing bridge controls, so the menu can save the bot token, save the admin user ID, set the interaction mode, start the bridge, stop it, and show status. The other platform adapters expose the shared connector configuration surface: enable/disable, token environment variable, base URL or webhook URL, default target/channel/room, polling vs webhook mode, redacted config display, and status/health reporting.
 
 Use environment variables for credentials:
 
@@ -3416,7 +3416,7 @@ The steering sub-agent uses the same model and backend as the main agent with `m
 
 <div align="right"><a href="#top">back to top</a></div>
 
-Connect the agent to a Telegram bot. Each incoming message spawns a dedicated sub-agent that handles the conversation independently — visible in the terminal waterfall alongside other agent activity.
+Connect the agent to a Telegram bot. Telegram can run in auto, chat, or action mode: conversational messages get rapid streamed replies in chat mode, while codebase/file/run requests use dedicated action sub-agents that are visible in the terminal waterfall alongside other agent activity.
 
 ```bash
 /telegram --key <token>     # Save bot token (persisted to .oa/settings.json)
@@ -3424,6 +3424,7 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 /telegram                   # Toggle bridge on/off (uses saved key)
 /telegram status            # Show connection status + active sub-agents
 /telegram stop              # Disconnect and kill all sub-agents
+/telegram mode auto|chat|action # Set interaction routing profile
 /telegram auth              # Show a one-time TUI-only admin auth code
 /telegram auth cancel       # Cancel the pending admin auth code
 /telegram bot <username> <text>              # Send bot-to-bot message by @username
@@ -3438,7 +3439,17 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 /telegram delete-reactions <chat> --user <id>      # Delete recent reactions
 ```
 
-The bot token and admin ID are persisted to project settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
+The bot token, admin ID, and interaction mode are persisted to settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
+
+### Telegram Interaction Modes
+
+Use `/telegram mode auto|chat|action` to control how inbound Telegram messages are routed:
+
+- **auto** — short greetings, quick questions, playful messages, and conversational turns use fast streamed chat replies; explicit codebase/file/command/run/test requests use action sub-agents.
+- **chat** — every non-command message gets a direct quick-chat completion with no tool loop. This is best for rapid back-and-forth conversation.
+- **action** — every non-command message runs through the Telegram sub-agent path with the configured tool policy.
+
+Telegram quick-chat views and action sub-agent views both appear as blue plane-labeled items in the systems header. Clicking one swaps the main scrollable window to that Telegram-only content buffer; press Esc to return to the primary view.
 
 ### Telegram Admin Authentication
 
@@ -3462,7 +3473,7 @@ The Telegram bridge handles modern Bot API traffic directly:
 - **Direct-message channels** — direct-message channel/topic metadata is preserved on normalized Telegram messages for routing and future adapter logic.
 - **Drafts and profile chat reads** — `/telegram draft` can set or clear message drafts, and `/telegram personal <user_id> <limit>` fetches recent messages from a user's profile personal chat.
 - **Reactions/admin helpers** — `/telegram delete-reaction` removes a message reaction, `/telegram delete-reactions` removes recent reactions by a user/chat, and `/telegram admins <chat> [--bots]` can include bot administrators.
-- **TUI sub-agent visibility** — Telegram conversations register as blue plane-labeled sub-agent views in the systems panel and show an active plane indicator in the footer while the bridge or Telegram sub-agents are active.
+- **TUI Telegram visibility** — Telegram quick-chat and action conversations register as blue plane-labeled views in the systems panel; clicking a view swaps the main scrollable window to that Telegram-only buffer, and the footer shows an active plane indicator while the bridge or Telegram work is active.
 
 ### Admin Slash Command Passthrough
 

package/dist/index.js

@@ -549063,6 +549063,7 @@ var init_command_registry = __esm({
       ["/telegram", "Toggle Telegram bridge on/off (uses saved key)"],
       ["/telegram status", "Show Telegram bridge status"],
       ["/telegram stop", "Disconnect Telegram bridge"],
+      ["/telegram mode auto|chat|action", "Set Telegram interaction routing: auto, fast chat, or action sub-agent"],
       ["/telegram auth", "Show a TUI-only one-time code for Telegram admin authentication"],
       ["/telegram auth cancel", "Cancel the pending Telegram admin authentication code"],
       ["/telegram bot <username> <text>", "Send a Bot API bot-to-bot message by @username"],
@@ -558482,6 +558483,8 @@ var init_status_bar = __esm({
           zones.push({ w: 2, render: () => "" });
           const voiceLabel = this._voiceActive ? ` ${this._voiceModelId || "voice"} ` : " voice ";
           zones.push({ w: voiceLabel.length + 2, render: () => "" });
+          const telegramLabel = this._telegramStatus.activeSubAgents > 0 ? ` ✈ tg ${this._telegramStatus.activeSubAgents} ` : " ✈ tg ";
+          zones.push({ w: telegramLabel.length + 2, render: () => "" });
           zones.push({ w: 9, render: () => "" });
           let pages = [];
           let cur = [];
@@ -559608,7 +559611,7 @@ var init_status_bar = __esm({
        *  If currently on the "systems" panel, re-render to show updated agent list. */
       renderAgentTabs() {
         if (!this.active) return;
-        if (this.currentHeaderPanel === "systems") {
+        if (String(this.currentHeaderPanel).startsWith("sys-")) {
           this.refreshHeaderContent();
         }
       }
@@ -579313,6 +579316,7 @@ sleep 1
     case "telegram":
     case "tg": {
       const parts = arg ? arg.split(/\s+/) : [];
+      const isLocal = hasLocal;
       if (parts[0] === "stop" || parts[0] === "off") {
         if (ctx3.isTelegramActive?.()) {
           ctx3.telegramStop?.();
@@ -579325,6 +579329,23 @@ sleep 1
         ctx3.telegramStatus?.();
         return "handled";
       }
+      if (parts[0] === "mode" || parts[0] === "profile") {
+        const requested = parts.slice(1).find((part) => !part.startsWith("--"));
+        if (!requested) {
+          const current = ctx3.getTelegramSettings?.()?.mode ?? "auto";
+          renderInfo(`Telegram interaction mode: ${c3.bold(current)}`);
+          renderInfo("Modes: auto (chat vs action), chat (fast replies), action (sub-agent tool loop).");
+          return "handled";
+        }
+        if (requested !== "auto" && requested !== "chat" && requested !== "action") {
+          renderWarning("Usage: /telegram mode auto|chat|action [--local]");
+          return "handled";
+        }
+        ctx3.saveTelegramSettings?.({ mode: requested, local: isLocal });
+        ctx3.telegramSetInteractionMode?.(requested);
+        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${isLocal ? " (project)" : " (global)"}.`);
+        return "handled";
+      }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
         if (parts[1] === "cancel") {
           const cancelled = ctx3.telegramCancelAdminAuth?.() ?? false;
@@ -579500,7 +579521,6 @@ sleep 1
         }
         return "handled";
       }
-      const isLocal = parts.includes("--local");
       const keyIdx = parts.indexOf("--key");
       const adminIdx = parts.indexOf("--admin");
       if (keyIdx !== -1 || adminIdx !== -1) {
@@ -579570,6 +579590,7 @@ sleep 1
       renderInfo("  /telegram                 Toggle on/off");
       renderInfo("  /telegram stop            Stop bridge");
       renderInfo("  /telegram status          Show status");
+      renderInfo("  /telegram mode auto|chat|action  Set interaction routing profile");
       renderInfo("  /telegram auth            Show one-time admin auth code");
       renderInfo("  /telegram auth cancel     Cancel pending admin auth code");
       renderInfo("  /telegram bot <username> <text>  Send bot-to-bot message");
@@ -580072,6 +580093,15 @@ async function showConfigEditor(ctx3) {
       value: String(merged.telegramAdmin ?? "[not set]"),
       detail: String(merged.telegramAdmin ?? "[not set]")
     },
+    {
+      key: "telegramMode",
+      label: "telegramMode",
+      kind: "enum",
+      value: String(merged.telegramMode ?? "auto"),
+      detail: String(merged.telegramMode ?? "auto"),
+      options: ["auto", "chat", "action"],
+      settingsKey: "telegramMode"
+    },
     // -- Actions --
     {
       key: "__h_actions__",
@@ -580337,6 +580367,7 @@ async function showPlatformOnboardingMenu(ctx3, id) {
     { key: "telegram-status", label: "Status", detail: "Show bridge status" },
     { key: "telegram-token", label: "Set bot token", detail: "Saved to existing Telegram settings" },
     { key: "telegram-admin", label: "Set admin user id", detail: "Restricts remote admin controls" },
+    { key: "telegram-mode", label: "Interaction mode", detail: ctx3.getTelegramSettings?.()?.mode ?? "auto" },
     { key: "telegram-start", label: "Start bridge", detail: "Uses saved token" },
     { key: "telegram-stop", label: "Stop bridge", detail: "Disconnect long polling" }
   ] : [
@@ -580415,7 +580446,13 @@ async function showPlatformOnboardingMenu(ctx3, id) {
   if (!result.confirmed || !result.key) return;
   if (id === "telegram") {
     if (result.key === "telegram-status") ctx3.telegramStatus?.();
-    else if (result.key === "telegram-start") {
+    else if (result.key === "telegram-mode") {
+      const current2 = ctx3.getTelegramSettings?.()?.mode ?? "auto";
+      const next = current2 === "auto" ? "chat" : current2 === "chat" ? "action" : "auto";
+      ctx3.saveTelegramSettings?.({ mode: next });
+      ctx3.telegramSetInteractionMode?.(next);
+      renderInfo(`Telegram interaction mode set to ${next}.`);
+    } else if (result.key === "telegram-start") {
       const settings = ctx3.getTelegramSettings?.() ?? {};
       if (!settings.key) renderWarning("No Telegram bot token configured.");
       else await ctx3.telegramStart?.(settings.key, settings.admin);
@@ -590857,6 +590894,28 @@ import { mkdirSync as mkdirSync58, existsSync as existsSync100, unlinkSync as un
 import { join as join117, resolve as resolve35, basename as basename21 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 import { createHash as createHash18, randomInt } from "node:crypto";
+function classifyTelegramInteraction(text, mode = "auto", options2 = {}) {
+  if (mode === "chat") return "chat";
+  if (mode === "action") return "action";
+  const trimmed = text.trim();
+  if (!trimmed) return "chat";
+  if (options2.isSlashCommand || trimmed.startsWith("/")) return "action";
+  if (options2.hasMedia) return "action";
+  const hasAction = TELEGRAM_ACTION_INTENT_RE.test(trimmed);
+  const hasCodebaseContext = TELEGRAM_CODEBASE_CONTEXT_RE.test(trimmed) || TELEGRAM_COMMANDISH_RE.test(trimmed) || /[`'"]?[\w./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|java|css|scss|html|yml|yaml|toml|sh|sql)[`'"]?/i.test(trimmed);
+  if (hasAction && hasCodebaseContext) return "action";
+  if (/^(please\s+|pls\s+|can you\s+|could you\s+|we need to\s+|i need you to\s+)?(fix|implement|patch|edit|refactor|run|test|build|install|debug|commit|deploy|publish)\b/i.test(trimmed)) {
+    return "action";
+  }
+  if (TELEGRAM_COMMANDISH_RE.test(trimmed)) return "action";
+  if (trimmed.includes("```") && hasAction) return "action";
+  if (trimmed.length > 360 && hasAction) return "action";
+  if (/\b(write|draft)\b.*\b(poem|story|joke|email|message|caption|song|haiku)\b/i.test(trimmed)) return "chat";
+  if (TELEGRAM_CHAT_INTENT_RE.test(trimmed)) return "chat";
+  if (/[?？]\s*$/.test(trimmed) && !hasAction) return "chat";
+  if (trimmed.length <= 180 && !hasCodebaseContext && !hasAction) return "chat";
+  return hasAction ? "action" : "chat";
+}
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
   html = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -591160,11 +591219,13 @@ function mimeForPath(path11, fallbackKind) {
   if (fallbackKind === "video") return "video/mp4";
   return "application/octet-stream";
 }
-function renderTelegramStart(botUsername, adminId) {
+function renderTelegramStart(botUsername, adminId, mode = "auto") {
   process.stdout.write(`
   ${c3.cyan("✈")} ${c3.bold("Telegram Bridge")} connected as @${botUsername}
 `);
-  process.stdout.write(`    ${c3.dim("Sub-agent mode: each message spawns a dedicated agent")}
+  process.stdout.write(`    ${c3.dim(`Interaction mode: ${mode}`)}
+`);
+  process.stdout.write(`    ${c3.dim("Auto mode uses quick chat for conversational turns and sub-agents for action requests")}
 `);
   if (adminId) {
     process.stdout.write(`    ${c3.dim(`Admin: ${adminId} (full memory + tools)`)}
@@ -591178,17 +591239,19 @@ function renderTelegramStart(botUsername, adminId) {
 
 `);
 }
-function renderTelegramStatus(active, botUsername, adminId, activeSubAgents) {
+function renderTelegramStatus(active, botUsername, adminId, activeSubAgents, mode = "auto") {
   if (active) {
     process.stdout.write(`
   ${c3.green("●")} Telegram bridge: ${c3.bold("ACTIVE")} (@${botUsername ?? "?"})
+`);
+    process.stdout.write(`    Mode: ${mode}
 `);
     if (adminId) {
       process.stdout.write(`    Admin: ${adminId}
 `);
     }
     if (activeSubAgents && activeSubAgents > 0) {
-      process.stdout.write(`    Active sub-agents: ${activeSubAgents}
+      process.stdout.write(`    Active Telegram work: ${activeSubAgents}
 `);
     }
     process.stdout.write(`    ${c3.dim("Use /telegram to toggle off")}
@@ -591246,7 +591309,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("⎿")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, GROUP_REPLY_DISCRETION_PROMPT, MEDIA_CACHE_TTL_MS, TelegramBridge;
+var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, TELEGRAM_ACTION_INTENT_RE, TELEGRAM_CODEBASE_CONTEXT_RE, TELEGRAM_COMMANDISH_RE, TELEGRAM_CHAT_INTENT_RE, MEDIA_CACHE_TTL_MS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -591306,6 +591369,20 @@ REPLY DISCRETION: You are in a group chat. Only respond if:
 If the message is casual group chatter not directed at you, use task_complete
 with summary "no_reply" to silently skip without responding.
 `.trim();
+    TELEGRAM_CHAT_MODE_PROMPT = `
+You are Open Agents replying in Telegram quick-chat mode.
+
+Rules:
+1. Reply directly to the Telegram user, conversationally and concisely.
+2. Do not inspect, summarize, or expose local files, paths, secrets, tool output, or runtime internals.
+3. Do not claim that you changed code, ran commands, or checked the workspace in quick-chat mode.
+4. If the user asks for codebase action while quick-chat mode is forced, tell them to switch Telegram to action mode or send a concrete action request in auto mode.
+5. For ordinary chat, status questions, greetings, quick explanations, and playful messages, answer immediately without tool-use narration.
+`.trim();
+    TELEGRAM_ACTION_INTENT_RE = /\b(implement|fix|patch|edit|write|create|delete|remove|refactor|run|execute|test|build|install|debug|investigate|diagnose|validate|commit|push|pull|merge|rebase|deploy|publish|read|open|inspect|grep|search|find|list|apply|change|update)\b/i;
+    TELEGRAM_CODEBASE_CONTEXT_RE = /\b(repo|repository|codebase|workspace|working directory|file|files|folder|directory|src|source|test|tests|package|pnpm|npm|node|git|branch|commit|pr|pull request|issue|shell|terminal|cli|command|function|class|component|endpoint|api)\b/i;
+    TELEGRAM_COMMANDISH_RE = /(^|\s)(pnpm|npm|node|git|rg|grep|sed|cat|ls|cd|mkdir|rm|mv|cp|curl|docker|pytest|vitest|tsc)\b/i;
+    TELEGRAM_CHAT_INTENT_RE = /\b(hi|hello|hey|thanks|thank you|lol|haha|joke|how are you|what's up|whats up|can you hear|are you there|explain|what is|what are|why|how does|tell me|opinion|quick question)\b/i;
     MEDIA_CACHE_TTL_MS = 30 * 60 * 1e3;
     TelegramBridge = class {
       constructor(botToken, onMessage, agentConfig, repoRoot, toolPolicyConfig) {
@@ -591327,6 +591404,7 @@ with summary "no_reply" to silently skip without responding.
         active: false,
         botUsername: "",
         supportsGuestQueries: false,
+        interactionMode: "auto",
         startedAt: "",
         messagesReceived: 0,
         messagesSent: 0,
@@ -591336,6 +591414,12 @@ with summary "no_reply" to silently skip without responding.
       adminUserId = null;
       /** Active sub-agents by chat/guest session key */
       subAgents = /* @__PURE__ */ new Map();
+      /** Active direct chat completions, counted with Telegram activity in the TUI */
+      activeChatViews = /* @__PURE__ */ new Set();
+      /** Lightweight chat history by chat/guest session key */
+      chatHistory = /* @__PURE__ */ new Map();
+      /** Telegram interaction routing profile */
+      interactionMode = "auto";
       /** Event handler for forwarding sub-agent events to parent TUI */
       onSubAgentEvent = null;
       /** Tool policy config — user overrides from config */
@@ -591375,6 +591459,13 @@ with summary "no_reply" to silently skip without responding.
       setAdmin(userId) {
         this.adminUserId = userId;
       }
+      setInteractionMode(mode) {
+        this.interactionMode = mode;
+        this.state.interactionMode = mode;
+      }
+      getInteractionMode() {
+        return this.interactionMode;
+      }
       /** Update tool policy config at runtime (e.g., from /disable command) */
       setToolPolicyConfig(config) {
         this.toolPolicyConfig = config;
@@ -591418,7 +591509,7 @@ with summary "no_reply" to silently skip without responding.
         return this.polling;
       }
       get stats() {
-        return { ...this.state, activeSubAgents: this.subAgents.size };
+        return { ...this.state, activeSubAgents: this.activeTelegramInteractionCount() };
       }
       get botUsername() {
         return this.state.botUsername;
@@ -591476,9 +591567,28 @@ with summary "no_reply" to silently skip without responding.
         if (msg.guestQueryId) return `guest:${msg.guestQueryId}`;
         return `chat:${String(msg.chatId)}`;
       }
+      activeTelegramInteractionCount() {
+        return this.subAgents.size + this.activeChatViews.size;
+      }
+      refreshActiveTelegramInteractionCount() {
+        this.state.activeSubAgents = this.activeTelegramInteractionCount();
+      }
       canUseChatActions(msg) {
         return !msg.guestQueryId && (typeof msg.chatId === "number" || String(msg.chatId).startsWith("@"));
       }
+      recordChatHistory(sessionKey, entry) {
+        const existing = this.chatHistory.get(sessionKey) ?? [];
+        existing.push(entry);
+        if (existing.length > 16) existing.splice(0, existing.length - 16);
+        this.chatHistory.set(sessionKey, existing);
+      }
+      shouldFastChatReplyInGroup(msg) {
+        if (msg.chatType === "private" || msg.guestQueryId) return true;
+        const lower = msg.text.toLowerCase();
+        const botMention = this.state.botUsername ? lower.includes(`@${this.state.botUsername.toLowerCase()}`) : false;
+        if (botMention || msg.replyToMessageId) return true;
+        return /[?？]/.test(msg.text) || /\b(help|question|how|what|why|when|where|can you|could you|explain)\b/i.test(msg.text);
+      }
       async handleAdminAuthCommand(msg) {
         const normalized = msg.text.trim();
         const lower = normalized.toLowerCase();
@@ -591542,6 +591652,7 @@ with summary "no_reply" to silently skip without responding.
           active: true,
           botUsername: me.result?.username ?? "unknown",
           supportsGuestQueries: Boolean(me.result?.supports_guest_queries),
+          interactionMode: this.interactionMode,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           messagesReceived: 0,
           messagesSent: 0,
@@ -591571,6 +591682,8 @@ with summary "no_reply" to silently skip without responding.
           if (agent.typingInterval) clearInterval(agent.typingInterval);
         }
         this.subAgents.clear();
+        this.activeChatViews.clear();
+        this.refreshActiveTelegramInteractionCount();
       }
       // ── Typing indicator ──────────────────────────────────────────────────
       /** Start sending "typing" indicator every 4 seconds */
@@ -591761,6 +591874,14 @@ Join: ${newUrl}`);
           }
           return;
         }
+        const route = classifyTelegramInteraction(msg.text, this.interactionMode, {
+          hasMedia: !!msg.media || !!msg.poll || !!msg.livePhoto,
+          isSlashCommand: msg.text.trim().startsWith("/")
+        });
+        if (route === "chat") {
+          await this.handleTelegramChatCompletion(msg, toolContext);
+          return;
+        }
         const subAgent = {
           chatId: msg.chatId,
           username: msg.username,
@@ -591776,7 +591897,7 @@ Join: ${newUrl}`);
           pendingMessages: []
         };
         this.subAgents.set(sessionKey, subAgent);
-        this.state.activeSubAgents = this.subAgents.size;
+        this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
           `✈ @${msg.username || "telegram"}`,
@@ -591846,10 +591967,173 @@ Join: ${newUrl}`);
           }
         } finally {
           this.subAgents.delete(sessionKey);
-          this.state.activeSubAgents = this.subAgents.size;
+          this.refreshActiveTelegramInteractionCount();
           this.subAgentViewCallbacks?.onComplete(subAgent.viewId);
         }
       }
+      /** Fast Telegram chat path: direct streamed completion, no tool loop. */
+      async handleTelegramChatCompletion(msg, toolContext) {
+        if (!this.shouldFastChatReplyInGroup(msg)) {
+          this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, "chat-mode discretion: skipped group chatter"));
+          return;
+        }
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const viewId = `${this.viewIdForMessage(msg)}-chat`;
+        let typingInterval = null;
+        let liveMessageId = null;
+        let accumulated = "";
+        let lastEditMs = 0;
+        let lastViewWriteMs = 0;
+        const progressLines = [`💬 Quick chat mode (${this.interactionMode})`];
+        this.activeChatViews.add(viewId);
+        this.refreshActiveTelegramInteractionCount();
+        this.subAgentViewCallbacks?.onRegister(
+          viewId,
+          `✈ @${msg.username || "telegram"}`,
+          `Telegram quick chat: ${msg.text.slice(0, 160)}`
+        );
+        this.subAgentViewCallbacks?.onWrite(viewId, `✈ Telegram quick chat from @${msg.username}: ${msg.text}`);
+        this.subAgentViewCallbacks?.onWrite(viewId, `route: chat (${this.interactionMode})`);
+        this.subAgentViewCallbacks?.onStatus(viewId, "running");
+        if (this.canUseChatActions(msg)) {
+          typingInterval = this.startTypingIndicator(msg.chatId);
+        }
+        this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `chat-mode fast reply (${this.interactionMode})`));
+        try {
+          if (!msg.guestQueryId) {
+            liveMessageId = await this.sendLiveMessage(
+              msg.chatId,
+              renderTelegramLiveProgressHTML(progressLines, ""),
+              msg.chatType !== "private" ? msg.messageId : void 0
+            );
+          }
+          const mediaContext = msg.media || msg.livePhoto ? "Attachment received. Quick-chat mode does not inspect media; use action mode for media analysis." : "";
+          const finalText = await this.runTelegramChatCompletion(
+            msg,
+            toolContext,
+            mediaContext,
+            (nextText) => {
+              accumulated = nextText;
+              const now = Date.now();
+              if (now - lastViewWriteMs > 900) {
+                lastViewWriteMs = now;
+                this.subAgentViewCallbacks?.onWrite(viewId, `stream: ${sanitizeTelegramProgressText(nextText, 180)}`);
+              }
+              if (liveMessageId && !msg.guestQueryId && now - lastEditMs > 900) {
+                lastEditMs = now;
+                this.editLiveMessage(
+                  msg.chatId,
+                  liveMessageId,
+                  renderTelegramLiveProgressHTML(progressLines, accumulated)
+                ).catch(() => {
+                });
+              }
+            }
+          );
+          if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+          }
+          const cleaned = stripTelegramHiddenThinking(finalText || accumulated).trim() || "I heard you.";
+          this.recordChatHistory(sessionKey, { role: "user", text: msg.text });
+          this.recordChatHistory(sessionKey, { role: "assistant", text: cleaned });
+          const finalHtml = convertMarkdownToTelegramHTML(cleaned);
+          if (liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, liveMessageId, finalHtml);
+          } else {
+            await this.replyToTelegramMessage(msg, finalHtml, {
+              html: true,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          }
+          this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
+          this.subAgentViewCallbacks?.onStatus(viewId, "completed");
+        } catch (err) {
+          if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+          }
+          const errMsg = err instanceof Error ? err.message : String(err);
+          this.tuiWrite(() => renderTelegramSubAgentError(msg.username, errMsg));
+          this.subAgentViewCallbacks?.onWrite(viewId, `error: ${errMsg}`);
+          this.subAgentViewCallbacks?.onStatus(viewId, "failed");
+          if (liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, liveMessageId, `❌ Error: ${escapeTelegramHTML(errMsg)}`).catch(() => {
+            });
+          } else {
+            await this.replyToTelegramMessage(msg, "Sorry, I couldn't process that quick chat message.").catch(() => {
+            });
+          }
+        } finally {
+          this.activeChatViews.delete(viewId);
+          this.refreshActiveTelegramInteractionCount();
+          this.subAgentViewCallbacks?.onComplete(viewId);
+        }
+      }
+      buildTelegramChatMessages(msg, toolContext, mediaContext = "") {
+        const isAdminDM = toolContext === "telegram-admin-dm";
+        const isAdminGroup = toolContext === "telegram-admin-group";
+        const isGroup = msg.chatType !== "private";
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const history = this.chatHistory.get(sessionKey) ?? [];
+        const safety = isAdminDM ? "Admin private DM. The user is trusted, but quick-chat mode still has no tool access." : isAdminGroup ? ADMIN_GROUP_PROMPT : TELEGRAM_SAFETY_PROMPT;
+        const groupHint = isGroup ? `Telegram group: ${msg.chatTitle || "unknown"}. Keep the reply short and relevant.` : "Telegram private chat.";
+        const messages2 = [
+          {
+            role: "system",
+            content: `${TELEGRAM_CHAT_MODE_PROMPT}
+
+${safety}
+
+${groupHint}`
+          },
+          ...history.slice(-8).map((entry) => ({
+            role: entry.role,
+            content: entry.text
+          }))
+        ];
+        const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        messages2.push({
+          role: "user",
+          content: `Telegram message from @${msg.username}${chatLabel}:
+${msg.text}${mediaContext ? `
+
+${mediaContext}` : ""}`
+        });
+        return messages2;
+      }
+      async runTelegramChatCompletion(msg, toolContext, mediaContext, onToken) {
+        const config = this.agentConfig;
+        const backend = new OllamaAgenticBackend(
+          config.backendUrl,
+          config.model,
+          config.apiKey
+        );
+        const request = {
+          messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
+          tools: [],
+          temperature: 0.4,
+          maxTokens: 700,
+          timeoutMs: Math.min(config.timeoutMs ?? 3e4, 3e4),
+          think: false
+        };
+        let accumulated = "";
+        const streamable = backend;
+        if (typeof streamable.chatCompletionStream === "function") {
+          for await (const chunk of streamable.chatCompletionStream(request)) {
+            if (chunk.type === "content" && !chunk.thinking && chunk.content) {
+              accumulated += chunk.content;
+              onToken(accumulated);
+            }
+          }
+        }
+        if (!accumulated.trim()) {
+          const result = await backend.chatCompletion(request);
+          accumulated = result.choices[0]?.message?.content ?? "";
+          if (accumulated) onToken(accumulated);
+        }
+        return stripTelegramHiddenThinking(accumulated).trim();
+      }
       /** Run a sub-agent for a Telegram message */
       async runSubAgent(msg, subAgent, mediaContext = "") {
         const config = this.agentConfig;
@@ -622073,6 +622357,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         currentConfig,
         repoRoot
       );
+      telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
       if (adminId) {
         telegramBridge.setAdmin(adminId);
       }
@@ -622185,7 +622470,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         );
       });
       writeContent(
-        () => renderTelegramStart(telegramBridge.botUsername, adminId)
+        () => renderTelegramStart(telegramBridge.botUsername, adminId, savedSettings.telegramMode ?? "auto")
       );
       showPrompt();
     },
@@ -622204,7 +622489,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     getTelegramSettings() {
       return {
         key: savedSettings.telegramKey,
-        admin: savedSettings.telegramAdmin
+        admin: savedSettings.telegramAdmin,
+        mode: savedSettings.telegramMode
       };
     },
     saveTelegramSettings(settings) {
@@ -622214,9 +622500,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (settings.admin !== void 0) {
         savedSettings.telegramAdmin = settings.admin;
       }
+      if (settings.mode !== void 0) {
+        savedSettings.telegramMode = settings.mode;
+      }
       const payload = {
         ...settings.key !== void 0 ? { telegramKey: settings.key } : {},
-        ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {}
+        ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {},
+        ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {}
       };
       if (settings.local) {
         saveProjectSettings(repoRoot, payload);
@@ -622224,6 +622514,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         saveGlobalSettings(payload);
       }
     },
+    telegramSetInteractionMode(mode) {
+      savedSettings.telegramMode = mode;
+      telegramBridge?.setInteractionMode(mode);
+    },
     telegramStatus() {
       const active = telegramBridge?.isActive ?? false;
       const botUser = active ? telegramBridge?.botUsername : void 0;
@@ -622233,7 +622527,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           active,
           botUser,
           savedSettings.telegramAdmin,
-          subAgents
+          subAgents,
+          savedSettings.telegramMode ?? "auto"
         )
       );
     },

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.583",
+  "version": "0.187.584",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.583",
+      "version": "0.187.584",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.583",
+  "version": "0.187.584",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",