@grinev/opencode-telegram-bot 0.13.2 → 0.14.0

package/.env.example

@@ -50,20 +50,12 @@ OPENCODE_MODEL_ID=big-pickle
 # Supported locales: en, de, es, fr, ru, zh
 # BOT_LOCALE=en
 
-# Service message batching interval in seconds (thinking + tool calls, default: 5)
-# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
-# 0 = send immediately (can hit rate limits if there are many tool calls)
-# SERVICE_MESSAGES_INTERVAL_SEC=5
-
 # Hide thinking indicator messages (default: false)
 # HIDE_THINKING_MESSAGES=false
 
 # Hide tool call service messages (default: false)
 # HIDE_TOOL_CALL_MESSAGES=false
 
-# Stream assistant responses while they are being generated (default: true)
-# RESPONSE_STREAMING=true
-
 # Assistant message formatting mode (default: markdown)
 # markdown = convert assistant replies to Telegram MarkdownV2
 # raw = show assistant replies as plain text

package/README.md

@@ -28,6 +28,7 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 - **Live status** — pinned message with current project, model, context usage, and changed files list, updated in real time
 - **Model switching** — pick models from OpenCode favorites and recent history directly in the chat (favorites are shown first)
 - **Agent modes** — switch between Plan and Build modes on the fly
+- **Subagent activity** — watch live subagent progress in chat, including the current task, agent, model, and active tool step
 - **Custom Commands** — run OpenCode custom commands (and built-ins like `init`/`review`) from an inline menu with confirmation
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, then forward recognized text to OpenCode
@@ -146,32 +147,30 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                        | Description                                                                                                  | Required | Default                  |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ------------------------ |
-| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                        |
-| `TELEGRAM_ALLOWED_USER_ID`      | Your numeric Telegram user ID                                                                                |   Yes    | —                        |
-| `TELEGRAM_PROXY_URL`            | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                     |    No    | —                        |
-| `OPENCODE_API_URL`              | OpenCode server URL                                                                                          |    No    | `http://localhost:4096`  |
-| `OPENCODE_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`               |
-| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                        |
-| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`               |
-| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`             |
-| `BOT_LOCALE`                    | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                             |    No    | `en`                     |
-| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
-| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    No    | `10`                     |
-| `COMMANDS_LIST_LIMIT`           | Commands per page in `/commands`                                                                             |    No    | `10`                     |
-| `TASK_LIMIT`                    | Maximum number of scheduled tasks that can exist at once                                                     |    No    | `10`                     |
-| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
-| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                  |
-| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                  |
-| `RESPONSE_STREAMING`            | Stream assistant replies while they are generated across one or more Telegram messages                       |    No    | `true`                   |
-| `MESSAGE_FORMAT_MODE`           | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                   |    No    | `markdown`               |
-| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                    |
-| `STT_API_URL`                   | Whisper-compatible API base URL (enables voice/audio transcription)                                          |    No    | —                        |
-| `STT_API_KEY`                   | API key for your STT provider                                                                                |    No    | —                        |
-| `STT_MODEL`                     | STT model name passed to `/audio/transcriptions`                                                             |    No    | `whisper-large-v3-turbo` |
-| `STT_LANGUAGE`                  | Optional language hint (empty = provider auto-detect)                                                        |    No    | —                        |
-| `LOG_LEVEL`                     | Log level (`debug`, `info`, `warn`, `error`)                                                                 |    No    | `info`                   |
+| Variable                   | Description                                                                      | Required | Default                  |
+| -------------------------- | -------------------------------------------------------------------------------- | :------: | ------------------------ |
+| `TELEGRAM_BOT_TOKEN`       | Bot token from @BotFather                                                        |   Yes    | —                        |
+| `TELEGRAM_ALLOWED_USER_ID` | Your numeric Telegram user ID                                                    |   Yes    | —                        |
+| `TELEGRAM_PROXY_URL`       | Proxy URL for Telegram API (SOCKS5/HTTP)                                         |    No    | —                        |
+| `OPENCODE_API_URL`         | OpenCode server URL                                                              |    No    | `http://localhost:4096`  |
+| `OPENCODE_SERVER_USERNAME` | Server auth username                                                             |    No    | `opencode`               |
+| `OPENCODE_SERVER_PASSWORD` | Server auth password                                                             |    No    | —                        |
+| `OPENCODE_MODEL_PROVIDER`  | Default model provider                                                           |   Yes    | `opencode`               |
+| `OPENCODE_MODEL_ID`        | Default model ID                                                                 |   Yes    | `big-pickle`             |
+| `BOT_LOCALE`               | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`) |    No    | `en`                     |
+| `SESSIONS_LIST_LIMIT`      | Sessions per page in `/sessions`                                                 |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`      | Projects per page in `/projects`                                                 |    No    | `10`                     |
+| `COMMANDS_LIST_LIMIT`      | Commands per page in `/commands`                                                 |    No    | `10`                     |
+| `TASK_LIMIT`               | Maximum number of scheduled tasks that can exist at once                         |    No    | `10`                     |
+| `HIDE_THINKING_MESSAGES`   | Hide `💭 Thinking...` service messages                                           |    No    | `false`                  |
+| `HIDE_TOOL_CALL_MESSAGES`  | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)             |    No    | `false`                  |
+| `MESSAGE_FORMAT_MODE`      | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`       |    No    | `markdown`               |
+| `CODE_FILE_MAX_SIZE_KB`    | Max file size (KB) to send as document                                           |    No    | `100`                    |
+| `STT_API_URL`              | Whisper-compatible API base URL (enables voice/audio transcription)              |    No    | —                        |
+| `STT_API_KEY`              | API key for your STT provider                                                    |    No    | —                        |
+| `STT_MODEL`                | STT model name passed to `/audio/transcriptions`                                 |    No    | `whisper-large-v3-turbo` |
+| `STT_LANGUAGE`             | Optional language hint (empty = provider auto-detect)                            |    No    | —                        |
+| `LOG_LEVEL`                | Log level (`debug`, `info`, `warn`, `error`)                                     |    No    | `info`                   |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 

package/dist/bot/commands/sessions.js

@@ -51,6 +51,7 @@ async function loadSessionPage(directory, page, pageSize) {
     const { data: sessions, error } = await opencodeClient.session.list({
         directory,
         limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
+        roots: true,
     });
     if (error || !sessions) {
         throw error || new Error("No data received from server");

package/dist/bot/index.js

@@ -37,6 +37,7 @@ import { keyboardManager } from "../keyboard/manager.js";
 import { subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatSummaryWithMode, formatToolInfo, getAssistantParseMode, } from "../summary/formatter.js";
+import { renderSubagentCards } from "../summary/subagent-formatter.js";
 import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { getCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
@@ -65,6 +66,7 @@ const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = 200;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
 const SESSION_RETRY_PREFIX = "🔁";
+const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
@@ -95,7 +97,6 @@ function prepareStreamingPayload(messageText) {
     };
 }
 const toolMessageBatcher = new ToolMessageBatcher({
-    intervalSeconds: 5,
     sendText: async (sessionId, text) => {
         if (!botInstance || !chatIdInstance) {
             return;
@@ -270,7 +271,6 @@ async function ensureEventSubscription(directory) {
         logger.error("No directory found for event subscription");
         return;
     }
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
     summaryAggregator.setTypingIndicatorEnabled(true);
     summaryAggregator.setOnCleared(() => {
         toolMessageBatcher.clearAll("summary_aggregator_clear");
@@ -278,9 +278,6 @@ async function ensureEventSubscription(directory) {
         responseStreamer.clearAll("summary_aggregator_clear");
     });
     summaryAggregator.setOnPartial((sessionId, messageId, messageText) => {
-        if (!config.bot.responseStreaming) {
-            return;
-        }
         if (!botInstance || !chatIdInstance) {
             return;
         }
@@ -292,7 +289,7 @@ async function ensureEventSubscription(directory) {
         if (!preparedStreamPayload) {
             return;
         }
-        preparedStreamPayload.sendOptions = undefined;
+        preparedStreamPayload.sendOptions = { disable_notification: true };
         preparedStreamPayload.editOptions = undefined;
         responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
     });
@@ -315,8 +312,7 @@ async function ensureEventSubscription(directory) {
         const botApi = botInstance.api;
         const chatId = chatIdInstance;
         try {
-            const streamedViaMessages = await finalizeAssistantResponse({
-                responseStreaming: config.bot.responseStreaming,
+            await finalizeAssistantResponse({
                 sessionId,
                 messageId,
                 messageText,
@@ -338,13 +334,17 @@ async function ensureEventSubscription(directory) {
                         format,
                     });
                 },
+                deleteMessages: async (messageIds) => {
+                    for (const msgId of messageIds) {
+                        try {
+                            await botApi.deleteMessage(chatId, msgId);
+                        }
+                        catch (err) {
+                            logger.warn(`[Bot] Failed to delete streamed message ${msgId}:`, err);
+                        }
+                    }
+                },
             });
-            if (streamedViaMessages) {
-                logger.debug(`[Bot] Final assistant message already streamed (session=${sessionId}, message=${messageId})`);
-                foregroundSessionState.markIdle(sessionId);
-                await scheduledTaskRuntime.flushDeferredDeliveries();
-                return;
-            }
         }
         catch (err) {
             logger.error("Failed to send message to Telegram:", err);
@@ -368,7 +368,9 @@ async function ensureEventSubscription(directory) {
         }
         const shouldIncludeToolInfoInFileCaption = toolInfo.hasFileAttachment &&
             (toolInfo.tool === "write" || toolInfo.tool === "edit" || toolInfo.tool === "apply_patch");
-        if (config.bot.hideToolCallMessages || shouldIncludeToolInfoInFileCaption) {
+        if (config.bot.hideToolCallMessages ||
+            shouldIncludeToolInfoInFileCaption ||
+            toolInfo.tool === "task") {
             return;
         }
         try {
@@ -381,6 +383,28 @@ async function ensureEventSubscription(directory) {
             logger.error("Failed to send tool notification to Telegram:", err);
         }
     });
+    summaryAggregator.setOnSubagent(async (sessionId, subagents) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        if (config.bot.hideToolCallMessages) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        try {
+            const renderedCards = await renderSubagentCards(subagents);
+            if (!renderedCards) {
+                return;
+            }
+            toolCallStreamer.replaceByPrefix(sessionId, SUBAGENT_STREAM_PREFIX, renderedCards);
+        }
+        catch (err) {
+            logger.error("Failed to render subagent activity for Telegram:", err);
+        }
+    });
     summaryAggregator.setOnToolFile(async (fileInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending file");
@@ -463,24 +487,38 @@ async function ensureEventSubscription(directory) {
         logger.debug("[Bot] Agent started thinking");
         await toolCallStreamer.breakSession(sessionId, "thinking_started");
         deliverThinkingMessage(sessionId, toolMessageBatcher, {
-            responseStreaming: config.bot.responseStreaming,
             hideThinkingMessages: config.bot.hideThinkingMessages,
         });
+        // Refresh pinned message so it shows the latest in-memory context
+        // (accumulated from silent token updates). 1 API call per thinking event.
+        if (pinnedMessageManager.isInitialized()) {
+            await pinnedMessageManager.refresh();
+        }
     });
-    summaryAggregator.setOnTokens(async (tokens) => {
+    summaryAggregator.setOnTokens(async (tokens, isCompleted) => {
         if (!pinnedMessageManager.isInitialized()) {
             return;
         }
         try {
-            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}`);
-            // Update keyboardManager SYNCHRONOUSLY before any await
-            // This ensures keyboard has correct context when onComplete sends the reply
+            logger.debug(`[Bot] Received tokens: input=${tokens.input}, output=${tokens.output}, completed=${isCompleted}`);
             const contextSize = tokens.input + tokens.cacheRead;
             const contextLimit = pinnedMessageManager.getContextLimit();
+            // Skip non-completed messages with zero context: a new assistant message
+            // starts with tokens={input:0, ...} which would overwrite valid context
+            // from the previous step. Only accept zeros from completed messages.
+            if (!isCompleted && contextSize === 0) {
+                logger.debug("[Bot] Skipping zero-token intermediate update");
+                return;
+            }
+            // Update both keyboard and pinned state in memory (keeps them in sync)
             if (contextLimit > 0) {
                 keyboardManager.updateContext(contextSize, contextLimit);
             }
-            await pinnedMessageManager.onMessageComplete(tokens);
+            pinnedMessageManager.updateTokensSilent(tokens);
+            // Full pinned message update (API call) only on completed messages
+            if (isCompleted) {
+                await pinnedMessageManager.onMessageComplete(tokens);
+            }
         }
         catch (err) {
             logger.error("[Bot] Error updating pinned message with tokens:", err);
@@ -600,8 +638,6 @@ async function ensureEventSubscription(directory) {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
-    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
-    logger.debug(`[ToolBatcher] Service messages interval: ${config.bot.serviceMessagesIntervalSec}s`);
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;

package/dist/bot/streaming/response-streamer.js

@@ -70,9 +70,10 @@ export class ResponseStreamer {
         this.ensureTimer(state);
     }
     async complete(sessionId, messageId, payload, options) {
+        const notStreamed = { streamed: false, telegramMessageIds: [] };
         const state = this.states.get(buildStateKey(sessionId, messageId));
         if (!state) {
-            return false;
+            return notStreamed;
         }
         if (payload) {
             const normalizedPayload = normalizePayload(payload);
@@ -86,12 +87,12 @@ export class ResponseStreamer {
             await this.cleanupBrokenStream(state, "complete_broken_stream");
             this.cancelState(state);
             this.states.delete(state.key);
-            return false;
+            return notStreamed;
         }
         if (state.telegramMessageIds.length === 0) {
             this.cancelState(state);
             this.states.delete(state.key);
-            return false;
+            return notStreamed;
         }
         let synced = true;
         if (options?.flushFinal !== false) {
@@ -100,9 +101,10 @@ export class ResponseStreamer {
                 await this.cleanupBrokenStream(state, "final_sync_failed_cleanup");
             }
         }
+        const messageIds = [...state.telegramMessageIds];
         this.cancelState(state);
         this.states.delete(state.key);
-        return synced;
+        return { streamed: synced, telegramMessageIds: messageIds };
     }
     clearMessage(sessionId, messageId, reason) {
         const key = buildStateKey(sessionId, messageId);

package/dist/bot/utils/finalize-assistant-response.js

@@ -1,16 +1,25 @@
-export async function finalizeAssistantResponse({ responseStreaming, sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, }) {
-    let streamedViaMessages = false;
-    if (responseStreaming) {
-        const preparedStreamPayload = prepareStreamingPayload(messageText);
-        if (preparedStreamPayload) {
-            preparedStreamPayload.sendOptions = undefined;
-            preparedStreamPayload.editOptions = undefined;
-        }
-        streamedViaMessages = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+import { logger } from "../../utils/logger.js";
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
+    let streamedMessageIds = [];
+    const preparedStreamPayload = prepareStreamingPayload(messageText);
+    if (preparedStreamPayload) {
+        preparedStreamPayload.sendOptions = { disable_notification: true };
+        preparedStreamPayload.editOptions = undefined;
+    }
+    const result = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
+    if (result.streamed) {
+        streamedMessageIds = result.telegramMessageIds;
     }
     await flushPendingServiceMessages();
-    if (streamedViaMessages) {
-        return true;
+    // When the response was streamed, delete the streamed messages and re-send
+    // via the non-streamed path so the reply keyboard carries the latest context.
+    if (streamedMessageIds.length > 0) {
+        try {
+            await deleteMessages(streamedMessageIds);
+        }
+        catch (err) {
+            logger.warn("[FinalizeResponse] Failed to delete streamed messages, sending with keyboard anyway:", err);
+        }
     }
     const parts = formatSummary(messageText);
     const format = resolveFormat();

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -6,6 +6,17 @@ const MARKDOWN_PARSE_ERROR_MARKERS = [
     "entity beginning",
     "bad request: can't parse",
 ];
+function stripMarkdownFormattingOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const rawOptions = {
+        ...options,
+    };
+    delete rawOptions.parse_mode;
+    delete rawOptions.entities;
+    return rawOptions;
+}
 function getErrorText(error) {
     const parts = [];
     if (error instanceof Error) {
@@ -52,7 +63,7 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, optio
             throw error;
         }
         logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
-        return api.sendMessage(chatId, text, options);
+        return api.sendMessage(chatId, text, stripMarkdownFormattingOptions(options));
     }
 }
 export async function editMessageWithMarkdownFallback({ api, chatId, messageId, text, options, parseMode, }) {
@@ -71,6 +82,6 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
             throw error;
         }
         logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
-        return api.editMessageText(chatId, messageId, text, options);
+        return api.editMessageText(chatId, messageId, text, stripMarkdownFormattingOptions(options));
     }
 }

package/dist/bot/utils/thinking-message.js

@@ -4,6 +4,5 @@ export function deliverThinkingMessage(sessionId, batcher, options) {
         return;
     }
     const message = t("bot.thinking");
-    void options.responseStreaming;
     batcher.sendTextNow(sessionId, message, "thinking_started");
 }

package/dist/config.js

@@ -21,20 +21,6 @@ function getOptionalPositiveIntEnvVar(key, defaultValue) {
     }
     return parsedValue;
 }
-function getOptionalNonNegativeIntEnvVarFromKeys(keys, defaultValue) {
-    for (const key of keys) {
-        const value = getEnvVar(key, false);
-        if (!value) {
-            continue;
-        }
-        const parsedValue = Number.parseInt(value, 10);
-        if (Number.isNaN(parsedValue) || parsedValue < 0) {
-            return defaultValue;
-        }
-        return parsedValue;
-    }
-    return defaultValue;
-}
 function getOptionalLocaleEnvVar(key, defaultValue) {
     const value = getEnvVar(key, false);
     return normalizeLocale(value, defaultValue);
@@ -88,10 +74,8 @@ export const config = {
         commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
         taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
-        serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
         hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
-        responseStreaming: getOptionalBooleanEnvVar("RESPONSE_STREAMING", true),
         messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
     },
     files: {

package/dist/i18n/de.js

@@ -217,6 +217,18 @@ export const de = {
     "pinned.line.model": "Modell: {model}",
     "pinned.line.context": "Kontext: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Kosten: {cost} ausgegeben",
+    "subagent.header": "Subagent {agent}: {description}",
+    "subagent.line.status": "Status: {status}",
+    "subagent.line.task": "Aufgabe: {task}",
+    "subagent.line.agent": "Agent: {agent}",
+    "subagent.working": "Arbeitet...",
+    "subagent.working_with_details": "Arbeitet: {details}",
+    "subagent.completed": "Abgeschlossen",
+    "subagent.failed": "Aufgabe fehlgeschlagen",
+    "subagent.status.pending": "ausstehend",
+    "subagent.status.running": "laeuft",
+    "subagent.status.completed": "abgeschlossen",
+    "subagent.status.error": "Fehler",
     "pinned.files.title": "Dateien ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... und {count} mehr",

package/dist/i18n/en.js

@@ -217,6 +217,18 @@ export const en = {
     "pinned.line.model": "Model: {model}",
     "pinned.line.context": "Context: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Cost: {cost} spent",
+    "subagent.header": "Subagent {agent}: {description}",
+    "subagent.line.status": "Status: {status}",
+    "subagent.line.task": "Task: {task}",
+    "subagent.line.agent": "Agent: {agent}",
+    "subagent.working": "Working...",
+    "subagent.working_with_details": "Working: {details}",
+    "subagent.completed": "Completed",
+    "subagent.failed": "Task failed",
+    "subagent.status.pending": "pending",
+    "subagent.status.running": "running",
+    "subagent.status.completed": "completed",
+    "subagent.status.error": "error",
     "pinned.files.title": "Files ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... and {count} more",

package/dist/i18n/es.js

@@ -217,6 +217,18 @@ export const es = {
     "pinned.line.model": "Modelo: {model}",
     "pinned.line.context": "Contexto: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Costo: {cost} gastado",
+    "subagent.header": "Subagente {agent}: {description}",
+    "subagent.line.status": "Estado: {status}",
+    "subagent.line.task": "Tarea: {task}",
+    "subagent.line.agent": "Agente: {agent}",
+    "subagent.working": "Trabajando...",
+    "subagent.working_with_details": "Trabajando: {details}",
+    "subagent.completed": "Completada",
+    "subagent.failed": "Error de tarea",
+    "subagent.status.pending": "pendiente",
+    "subagent.status.running": "en ejecucion",
+    "subagent.status.completed": "completado",
+    "subagent.status.error": "error",
     "pinned.files.title": "Archivos ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... y {count} más",

package/dist/i18n/fr.js

@@ -217,6 +217,18 @@ export const fr = {
     "pinned.line.model": "Modèle : {model}",
     "pinned.line.context": "Contexte : {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Coût : {cost} dépensé",
+    "subagent.header": "Sous-agent {agent} : {description}",
+    "subagent.line.status": "Statut : {status}",
+    "subagent.line.task": "Tache : {task}",
+    "subagent.line.agent": "Agent : {agent}",
+    "subagent.working": "En cours...",
+    "subagent.working_with_details": "En cours : {details}",
+    "subagent.completed": "Terminee",
+    "subagent.failed": "Echec de la tache",
+    "subagent.status.pending": "en attente",
+    "subagent.status.running": "en cours",
+    "subagent.status.completed": "termine",
+    "subagent.status.error": "erreur",
     "pinned.files.title": "Fichiers ({count}) :",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... et encore {count}",

package/dist/i18n/ru.js

@@ -217,6 +217,18 @@ export const ru = {
     "pinned.line.model": "Модель: {model}",
     "pinned.line.context": "Контекст: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Стоимость: {cost} потрачено",
+    "subagent.header": "Сабагент {agent}: {description}",
+    "subagent.line.status": "Статус: {status}",
+    "subagent.line.task": "Задача: {task}",
+    "subagent.line.agent": "Агент: {agent}",
+    "subagent.working": "В работе...",
+    "subagent.working_with_details": "В работе: {details}",
+    "subagent.completed": "Завершена",
+    "subagent.failed": "Ошибка задачи",
+    "subagent.status.pending": "ожидание",
+    "subagent.status.running": "в работе",
+    "subagent.status.completed": "завершен",
+    "subagent.status.error": "ошибка",
     "pinned.files.title": "Файлы ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... и еще {count}",

package/dist/i18n/zh.js

@@ -217,6 +217,18 @@ export const zh = {
     "pinned.line.model": "模型: {model}",
     "pinned.line.context": "上下文: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "费用: {cost}",
+    "subagent.header": "子代理 {agent}: {description}",
+    "subagent.line.status": "状态: {status}",
+    "subagent.line.task": "任务: {task}",
+    "subagent.line.agent": "代理: {agent}",
+    "subagent.working": "执行中...",
+    "subagent.working_with_details": "执行中: {details}",
+    "subagent.completed": "已完成",
+    "subagent.failed": "任务失败",
+    "subagent.status.pending": "等待中",
+    "subagent.status.running": "运行中",
+    "subagent.status.completed": "已完成",
+    "subagent.status.error": "错误",
     "pinned.files.title": "文件（{count}）：",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... 还有 {count} 个",

package/dist/model/context-limit.js

@@ -0,0 +1,57 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+import { DEFAULT_CONTEXT_LIMIT } from "../pinned/format.js";
+const PROVIDER_CACHE_TTL_MS = 10 * 60 * 1000;
+const contextLimitCache = new Map();
+let providersCacheExpiresAt = 0;
+let providersFetchInFlight = null;
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+async function refreshContextLimitCache() {
+    if (Date.now() < providersCacheExpiresAt) {
+        return;
+    }
+    if (providersFetchInFlight) {
+        await providersFetchInFlight;
+        return;
+    }
+    providersFetchInFlight = (async () => {
+        try {
+            const { data, error } = await opencodeClient.config.providers();
+            if (error || !data) {
+                logger.warn("[ModelContextLimit] Failed to fetch providers:", error);
+                return;
+            }
+            contextLimitCache.clear();
+            for (const provider of data.providers) {
+                for (const [modelID, model] of Object.entries(provider.models)) {
+                    if (model?.limit?.context) {
+                        contextLimitCache.set(getModelKey(provider.id, modelID), model.limit.context);
+                    }
+                }
+            }
+            providersCacheExpiresAt = Date.now() + PROVIDER_CACHE_TTL_MS;
+            logger.debug(`[ModelContextLimit] Cached limits for ${contextLimitCache.size} provider/model pairs`);
+        }
+        catch (error) {
+            logger.warn("[ModelContextLimit] Error refreshing providers cache:", error);
+        }
+        finally {
+            providersFetchInFlight = null;
+        }
+    })();
+    await providersFetchInFlight;
+}
+export async function getModelContextLimit(providerID, modelID) {
+    if (!providerID || !modelID) {
+        return DEFAULT_CONTEXT_LIMIT;
+    }
+    const cacheKey = getModelKey(providerID, modelID);
+    const cachedLimit = contextLimitCache.get(cacheKey);
+    if (cachedLimit) {
+        return cachedLimit;
+    }
+    await refreshContextLimitCache();
+    return contextLimitCache.get(cacheKey) ?? DEFAULT_CONTEXT_LIMIT;
+}

package/dist/pinned/format.js

@@ -0,0 +1,29 @@
+import { t } from "../i18n/index.js";
+export const DEFAULT_CONTEXT_LIMIT = 200000;
+export function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    }
+    if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return count.toString();
+}
+export function formatModelDisplayName(providerID, modelID) {
+    if (providerID && modelID) {
+        return `${providerID}/${modelID}`;
+    }
+    return t("pinned.unknown");
+}
+export function formatContextLine(tokensUsed, tokensLimit) {
+    const safeLimit = typeof tokensLimit === "number" && tokensLimit > 0 ? tokensLimit : null;
+    const percentage = safeLimit ? Math.round((tokensUsed / safeLimit) * 100) : 0;
+    return t("pinned.line.context", {
+        used: formatTokenCount(tokensUsed),
+        limit: safeLimit ? formatTokenCount(safeLimit) : t("pinned.unknown"),
+        percent: percentage,
+    });
+}
+export function formatCostLine(cost) {
+    return t("pinned.line.cost", { cost: `$${cost.toFixed(2)}` });
+}