@grinev/opencode-telegram-bot 0.9.2 → 0.10.1

package/README.md

@@ -11,9 +11,9 @@ Run AI coding tasks, monitor progress, switch models, and manage sessions from y
 
 No open ports, no exposed APIs. The bot communicates with your local OpenCode server and the Telegram Bot API only.
 
-Languages: English (`en`), Deutsch (`de`), Español (`es`), Русский (`ru`), 简体中文 (`zh`)
+Platforms: macOS, Windows, Linux
 
-Quick start: `npx @grinev/opencode-telegram-bot`
+Languages: English (`en`), Deutsch (`de`), Español (`es`), Русский (`ru`), 简体中文 (`zh`)
 
 <p align="center">
   <img src="assets/screencast.gif" width="45%" alt="OpenCode Telegram Bot screencast" />
@@ -24,7 +24,7 @@ Quick start: `npx @grinev/opencode-telegram-bot`
 - **Remote coding** — send prompts to OpenCode from anywhere, receive complete results with code sent as files
 - **Session management** — create new sessions or continue existing ones, just like in the TUI
 - **Live status** — pinned message with current project, model, context usage, and changed files list, updated in real time
-- **Model switching** — pick any model from your OpenCode favorites directly in the chat
+- **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
 - **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
@@ -68,6 +68,8 @@ The fastest way — run directly with `npx`:
 npx @grinev/opencode-telegram-bot
 ```
 
+> Quick start is for npm usage. You do not need to clone this repository. If you run this command from the source directory (repository root), it may fail with `opencode-telegram: not found`. To run from sources, use the [Development](#development) section.
+
 On first launch, an interactive wizard will guide you through the configuration — it asks for interface language first, then your bot token, user ID, and OpenCode API URL. After that, you're ready to go. Open your bot in Telegram and start sending tasks.
 
 #### Alternative: Global Install
@@ -85,11 +87,11 @@ opencode-telegram config
 
 ## Supported Platforms
 
-| Platform | Status                                                                                                                               |
-| -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| macOS    | Fully supported                                                                                                                      |
-| Windows  | Fully supported                                                                                                                      |
-| Linux    | Experimental — should work, but has not been extensively tested. You may need additional steps such as granting execute permissions. |
+| Platform | Status                                       |
+| -------- | -------------------------------------------- |
+| macOS    | Fully supported                              |
+| Windows  | Fully supported                              |
+| Linux    | Fully supported (tested on Ubuntu 24.04 LTS) |
 
 ## Bot Commands
 
@@ -136,8 +138,8 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `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`, `ru`, `zh`)                                   |    No    | `en`                     |
-| `SESSIONS_LIST_LIMIT`           | Max sessions shown in `/sessions`                                                                            |    No    | `10`                     |
-| `PROJECTS_LIST_LIMIT`           | Max projects shown in `/projects`                                                                            |    No    | `10`                     |
+| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    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`                  |
@@ -176,15 +178,14 @@ If STT variables are not set, voice/audio transcription is disabled and the bot
 
 ### Model Configuration
 
-The bot picks up your **favorite models** from OpenCode. To add a model to favorites:
+The model picker uses OpenCode local model state (`favorite` + `recent`):
 
-1. Open OpenCode TUI (`opencode`)
-2. Go to model selection
-3. Hover over the model you want and press **Ctrl+F** to add it to favorites
+- Favorites are shown first, then recent
+- Models already in favorites are not duplicated in recent
+- Current model is marked with `✅`
+- Default model from `OPENCODE_MODEL_PROVIDER` + `OPENCODE_MODEL_ID` is always included in favorites
 
-These favorites will appear in the model picker opened from the bottom Telegram keyboard.
-
-A free model (`opencode/big-pickle`) is configured as the default fallback — if you haven't set up any favorites yet, the bot will use it automatically.
+To add a model to favorites, open OpenCode TUI (`opencode`), go to model selection, and press **Cmd+F/Ctrl+F** on the model.
 
 ## Security
 
@@ -240,6 +241,7 @@ npm run dev
 **No models in model picker**
 
 - Add models to your OpenCode favorites: open OpenCode TUI, go to model selection, press **Ctrl+F** on desired models
+- Verify `OPENCODE_MODEL_PROVIDER` and `OPENCODE_MODEL_ID` point to an available model in your setup
 
 **Linux: permission denied errors**
 
@@ -250,6 +252,10 @@ npm run dev
 
 Please follow commit and release note conventions in [CONTRIBUTING.md](CONTRIBUTING.md).
 
+## Community
+
+Have questions, want to share your experience using the bot, or have an idea for a feature? Join the conversation in [GitHub Discussions](https://github.com/grinev/opencode-telegram-bot/discussions).
+
 ## License
 
 [MIT](LICENSE) © Ruslan Grinev

package/dist/agent/manager.js

@@ -8,15 +8,9 @@ import { logger } from "../utils/logger.js";
  * @returns Array of available agents (filtered by mode and hidden flag)
  */
 export async function getAvailableAgents() {
-    const project = getCurrentProject();
-    if (!project) {
-        logger.warn("[AgentManager] Cannot get agents: no project selected");
-        return [];
-    }
     try {
-        const { data: agents, error } = await opencodeClient.app.agents({
-            directory: project.worktree,
-        });
+        const project = getCurrentProject();
+        const { data: agents, error } = await opencodeClient.app.agents(project ? { directory: project.worktree } : undefined);
         if (error) {
             logger.error("[AgentManager] Failed to fetch agents:", error);
             return [];
@@ -34,9 +28,11 @@ export async function getAvailableAgents() {
         return [];
     }
 }
+const DEFAULT_AGENT = "build";
 /**
- * Get current agent from last session message or settings
- * @returns Current agent name or undefined
+ * Get current agent from last session message or settings.
+ * Falls back to "build" if nothing is stored.
+ * @returns Current agent name
  */
 export async function fetchCurrentAgent() {
     const storedAgent = getCurrentAgent();
@@ -44,7 +40,7 @@ export async function fetchCurrentAgent() {
     const project = getCurrentProject();
     if (!session || !project) {
         // No active session, return stored agent from settings
-        return storedAgent;
+        return storedAgent ?? DEFAULT_AGENT;
     }
     try {
         const { data: messages, error } = await opencodeClient.session.messages({
@@ -54,7 +50,7 @@ export async function fetchCurrentAgent() {
         });
         if (error || !messages || messages.length === 0) {
             logger.debug("[AgentManager] No messages found, using stored agent");
-            return storedAgent;
+            return storedAgent ?? DEFAULT_AGENT;
         }
         const lastAgent = messages[0].info.agent;
         logger.debug(`[AgentManager] Current agent from session: ${lastAgent}`);
@@ -68,11 +64,11 @@ export async function fetchCurrentAgent() {
         if (lastAgent && lastAgent !== storedAgent) {
             setCurrentAgent(lastAgent);
         }
-        return lastAgent || storedAgent;
+        return lastAgent || storedAgent || DEFAULT_AGENT;
     }
     catch (err) {
         logger.error("[AgentManager] Error fetching current agent:", err);
-        return storedAgent;
+        return storedAgent ?? DEFAULT_AGENT;
     }
 }
 /**

package/dist/bot/commands/projects.js

@@ -11,11 +11,12 @@ import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
-import { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { config } from "../../config.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const PROJECT_PAGE_CALLBACK_PREFIX = "projects:page:";
 function formatProjectButtonLabel(label, isActive) {
     const prefix = isActive ? "✅ " : "";
     const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
@@ -36,29 +37,84 @@ export function buildProjectButtonLabel(index, worktree) {
     const folderName = getProjectFolderName(worktree);
     return `${index + 1}. ${folderName} [${worktree}]`;
 }
+export function parseProjectPageCallback(data) {
+    if (!data.startsWith(PROJECT_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(PROJECT_PAGE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawPage)) {
+        return null;
+    }
+    return Number.parseInt(rawPage, 10);
+}
+export function calculateProjectsPaginationRange(totalProjects, page, pageSize) {
+    const safePageSize = Math.max(1, pageSize);
+    const totalPages = Math.max(1, Math.ceil(totalProjects / safePageSize));
+    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = normalizedPage * safePageSize;
+    const endIndex = Math.min(startIndex + safePageSize, totalProjects);
+    return {
+        page: normalizedPage,
+        totalPages,
+        startIndex,
+        endIndex,
+    };
+}
+function buildProjectsMenuText(currentProjectName, page, totalPages) {
+    const baseText = currentProjectName
+        ? t("projects.select_with_current", {
+            project: currentProjectName,
+        })
+        : t("projects.select");
+    if (totalPages <= 1) {
+        return baseText;
+    }
+    return `${baseText}\n\n${t("projects.page_indicator", {
+        current: String(page + 1),
+        total: String(totalPages),
+    })}`;
+}
+function buildProjectsKeyboard(projects, page) {
+    const keyboard = new InlineKeyboard();
+    const currentProject = getCurrentProject();
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(projects.length, page, pageSize);
+    projects.slice(startIndex, endIndex).forEach((project, index) => {
+        const isActive = currentProject &&
+            (project.id === currentProject.id || project.worktree === currentProject.worktree);
+        const label = buildProjectButtonLabel(startIndex + index, project.worktree);
+        const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
+        keyboard.text(labelWithCheck, `project:${project.id}`).row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("projects.prev_page"), `${PROJECT_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("projects.next_page"), `${PROJECT_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+function buildProjectsMenuView(projects, page) {
+    const currentProject = getCurrentProject();
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(projects.length, page, pageSize);
+    const currentProjectName = currentProject?.name || currentProject?.worktree || null;
+    return {
+        text: buildProjectsMenuText(currentProjectName, normalizedPage, totalPages),
+        keyboard: buildProjectsKeyboard(projects, normalizedPage),
+    };
+}
 export async function projectsCommand(ctx) {
     try {
         await syncSessionDirectoryCache();
         const projects = await getProjects();
-        const projectsToShow = projects.slice(0, config.bot.projectsListLimit);
-        if (projectsToShow.length === 0) {
+        if (projects.length === 0) {
             await ctx.reply(t("projects.empty"));
             return;
         }
-        const keyboard = new InlineKeyboard();
-        const currentProject = getCurrentProject();
-        projectsToShow.forEach((project, index) => {
-            const isActive = currentProject &&
-                (project.id === currentProject.id || project.worktree === currentProject.worktree);
-            const label = buildProjectButtonLabel(index, project.worktree);
-            const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
-            keyboard.text(labelWithCheck, `project:${project.id}`).row();
-        });
-        const text = currentProject
-            ? t("projects.select_with_current", {
-                project: currentProject.name || currentProject.worktree,
-            })
-            : t("projects.select");
+        const { text, keyboard } = buildProjectsMenuView(projects, 0);
         await replyWithInlineMenu(ctx, {
             menuKind: "project",
             text,
@@ -72,7 +128,35 @@ export async function projectsCommand(ctx) {
 }
 export async function handleProjectSelect(ctx) {
     const callbackQuery = ctx.callbackQuery;
-    if (!callbackQuery?.data || !callbackQuery.data.startsWith("project:")) {
+    if (!callbackQuery?.data) {
+        return false;
+    }
+    const page = parseProjectPageCallback(callbackQuery.data);
+    if (page !== null) {
+        const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
+        if (!isActiveMenu) {
+            return true;
+        }
+        try {
+            const projects = await getProjects();
+            if (projects.length === 0) {
+                await ctx.answerCallbackQuery();
+                await ctx.reply(t("projects.empty"));
+                return true;
+            }
+            const { text, keyboard } = buildProjectsMenuView(projects, page);
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "project"),
+            });
+        }
+        catch (error) {
+            logger.error("[Bot] Error switching projects page:", error);
+            await ctx.answerCallbackQuery({ text: t("projects.page_load_error") });
+        }
+        return true;
+    }
+    if (!callbackQuery.data.startsWith("project:")) {
         return false;
     }
     const projectId = callbackQuery.data.replace("project:", "");

package/dist/bot/commands/sessions.js

@@ -6,45 +6,105 @@ import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
-import { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { config } from "../../config.js";
 import { getDateLocale, t } from "../../i18n/index.js";
+const SESSION_CALLBACK_PREFIX = "session:";
+const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
+const SESSION_FETCH_EXTRA_COUNT = 1;
+function buildSessionPageCallback(page) {
+    return `${SESSION_PAGE_CALLBACK_PREFIX}${page}`;
+}
+function parseSessionPageCallback(data) {
+    if (!data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(SESSION_PAGE_CALLBACK_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+function parseSessionIdCallback(data) {
+    if (!data.startsWith(SESSION_CALLBACK_PREFIX)) {
+        return null;
+    }
+    if (data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const sessionId = data.slice(SESSION_CALLBACK_PREFIX.length);
+    return sessionId.length > 0 ? sessionId : null;
+}
+function formatSessionsSelectText(page) {
+    if (page === 0) {
+        return t("sessions.select");
+    }
+    return t("sessions.select_page", { page: page + 1 });
+}
+async function loadSessionPage(directory, page, pageSize) {
+    const startIndex = page * pageSize;
+    const endExclusive = startIndex + pageSize;
+    const { data: sessions, error } = await opencodeClient.session.list({
+        directory,
+        limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
+    });
+    if (error || !sessions) {
+        throw error || new Error("No data received from server");
+    }
+    const hasNext = sessions.length > endExclusive;
+    const pagedSessions = sessions.slice(startIndex, endExclusive);
+    logger.debug(`[Sessions] Loaded page=${page + 1}, startIndex=${startIndex}, endExclusive=${endExclusive}, pageSize=${pageSize}, items=${pagedSessions.length}, hasNext=${hasNext}`);
+    return {
+        sessions: pagedSessions,
+        hasNext,
+        page,
+    };
+}
+function buildSessionsKeyboard(pageData, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const localeForDate = getDateLocale();
+    const pageStartIndex = pageData.page * pageSize;
+    pageData.sessions.forEach((session, index) => {
+        const date = new Date(session.time.created).toLocaleDateString(localeForDate);
+        const label = `${pageStartIndex + index + 1}. ${session.title} (${date})`;
+        keyboard.text(label, `${SESSION_CALLBACK_PREFIX}${session.id}`).row();
+    });
+    if (pageData.page > 0) {
+        keyboard.text(t("sessions.button.prev_page"), buildSessionPageCallback(pageData.page - 1));
+    }
+    if (pageData.hasNext) {
+        keyboard.text(t("sessions.button.next_page"), buildSessionPageCallback(pageData.page + 1));
+    }
+    if (pageData.page > 0 || pageData.hasNext) {
+        keyboard.row();
+    }
+    return keyboard;
+}
 export async function sessionsCommand(ctx) {
     try {
-        const maxSessions = config.bot.sessionsListLimit;
+        const pageSize = config.bot.sessionsListLimit;
         const currentProject = getCurrentProject();
         if (!currentProject) {
             await ctx.reply(t("sessions.project_not_selected"));
             return;
         }
         logger.debug(`[Sessions] Fetching sessions for directory: ${currentProject.worktree}`);
-        const { data: sessions, error } = await opencodeClient.session.list({
-            directory: currentProject.worktree,
-            limit: maxSessions,
-        });
-        if (error || !sessions) {
-            throw error || new Error("No data received from server");
-        }
-        logger.debug(`[Sessions] Found ${sessions.length} sessions`);
-        sessions.forEach((session) => {
+        const firstPage = await loadSessionPage(currentProject.worktree, 0, pageSize);
+        logger.debug(`[Sessions] Found ${firstPage.sessions.length} sessions on page 1`);
+        firstPage.sessions.forEach((session) => {
             logger.debug(`[Sessions] Session: ${session.title} | ${session.directory}`);
         });
-        if (sessions.length === 0) {
+        if (firstPage.sessions.length === 0) {
             await ctx.reply(t("sessions.empty"));
             return;
         }
-        const keyboard = new InlineKeyboard();
-        const localeForDate = getDateLocale();
-        sessions.forEach((session, index) => {
-            const date = new Date(session.time.created).toLocaleDateString(localeForDate);
-            const label = `${index + 1}. ${session.title} (${date})`;
-            keyboard.text(label, `session:${session.id}`).row();
-        });
+        const keyboard = buildSessionsKeyboard(firstPage, pageSize);
         await replyWithInlineMenu(ctx, {
             menuKind: "session",
-            text: t("sessions.select"),
+            text: formatSessionsSelectText(firstPage.page),
             keyboard,
         });
     }
@@ -55,10 +115,11 @@ export async function sessionsCommand(ctx) {
 }
 export async function handleSessionSelect(ctx) {
     const callbackQuery = ctx.callbackQuery;
-    if (!callbackQuery?.data || !callbackQuery.data.startsWith("session:")) {
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith(SESSION_CALLBACK_PREFIX)) {
         return false;
     }
-    const sessionId = callbackQuery.data.replace("session:", "");
+    const page = parseSessionPageCallback(callbackQuery.data);
+    const sessionId = parseSessionIdCallback(callbackQuery.data);
     const isActiveMenu = await ensureActiveInlineMenu(ctx, "session");
     if (!isActiveMenu) {
         return true;
@@ -71,6 +132,31 @@ export async function handleSessionSelect(ctx) {
             await ctx.reply(t("sessions.select_project_first"));
             return true;
         }
+        if (page !== null) {
+            try {
+                const pageSize = config.bot.sessionsListLimit;
+                const pageData = await loadSessionPage(currentProject.worktree, page, pageSize);
+                if (pageData.sessions.length === 0) {
+                    await ctx.answerCallbackQuery({ text: t("sessions.page_empty_callback") });
+                    return true;
+                }
+                const keyboard = buildSessionsKeyboard(pageData, pageSize);
+                appendInlineMenuCancelButton(keyboard, "session");
+                await ctx.editMessageText(formatSessionsSelectText(pageData.page), {
+                    reply_markup: keyboard,
+                });
+                await ctx.answerCallbackQuery();
+            }
+            catch (error) {
+                logger.error("[Sessions] Error loading sessions page:", error);
+                await ctx.answerCallbackQuery({ text: t("sessions.page_load_error_callback") });
+            }
+            return true;
+        }
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+            return true;
+        }
         const { data: session, error } = await opencodeClient.session.get({
             sessionID: sessionId,
             directory: currentProject.worktree,

package/dist/bot/commands/status.js

@@ -6,6 +6,8 @@ import { getAgentDisplayName } from "../../agent/types.js";
 import { fetchCurrentModel } from "../../model/manager.js";
 import { formatModelForDisplay } from "../../model/types.js";
 import { processManager } from "../../process/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { sendMessageWithMarkdownFallback } from "../utils/send-with-markdown-fallback.js";
@@ -59,16 +61,33 @@ export async function statusCommand(ctx) {
             message += `\n${t("status.session_not_selected")}\n`;
             message += t("status.session_hint");
         }
+        if (ctx.chat) {
+            if (!pinnedMessageManager.isInitialized()) {
+                pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+            }
+            // Fetch context limit if not yet loaded (e.g. fresh bot start)
+            if (pinnedMessageManager.getContextLimit() === 0) {
+                await pinnedMessageManager.refreshContextLimit();
+            }
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Sync current context (tokens used + limit) into keyboard state
+        const contextInfo = pinnedMessageManager.getContextInfo();
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const keyboard = keyboardManager.getKeyboard();
         if (ctx.chat) {
             await sendMessageWithMarkdownFallback({
                 api: ctx.api,
                 chatId: ctx.chat.id,
                 text: message,
+                options: { reply_markup: keyboard },
                 parseMode: "Markdown",
             });
         }
         else {
-            await ctx.reply(message);
+            await ctx.reply(message, { reply_markup: keyboard });
         }
     }
     catch (error) {

package/dist/bot/handlers/agent.js

@@ -95,14 +95,24 @@ export async function buildAgentSelectionMenu(currentAgent) {
  * @param ctx grammY context
  */
 export async function showAgentSelectionMenu(ctx) {
-    const currentAgent = await fetchCurrentAgent();
-    const keyboard = await buildAgentSelectionMenu(currentAgent);
-    const text = currentAgent
-        ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
-        : t("agent.menu.select");
-    await replyWithInlineMenu(ctx, {
-        menuKind: "agent",
-        text,
-        keyboard,
-    });
+    try {
+        const currentAgent = await fetchCurrentAgent();
+        const keyboard = await buildAgentSelectionMenu(currentAgent);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("agent.menu.empty"));
+            return;
+        }
+        const text = currentAgent
+            ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
+            : t("agent.menu.select");
+        await replyWithInlineMenu(ctx, {
+            menuKind: "agent",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[AgentHandler] Error showing agent menu:", err);
+        await ctx.reply(t("agent.menu.error"));
+    }
 }

package/dist/bot/handlers/model.js

@@ -1,5 +1,5 @@
 import { InlineKeyboard } from "grammy";
-import { selectModel, getFavoriteModels, fetchCurrentModel } from "../../model/manager.js";
+import { selectModel, fetchCurrentModel, getModelSelectionLists } from "../../model/manager.js";
 import { formatModelForDisplay } from "../../model/types.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { logger } from "../../utils/logger.js";
@@ -7,19 +7,18 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { getStoredAgent } from "../../agent/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
-import { config } from "../../config.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
 import { t } from "../../i18n/index.js";
-function isOnlyConfigDefaultModel(models) {
-    if (models.length !== 1) {
-        return false;
+function buildModelSelectionMenuText(modelLists) {
+    const lines = [t("model.menu.select"), t("model.menu.favorites_title")];
+    if (modelLists.favorites.length === 0) {
+        lines.push(t("model.menu.favorites_empty"));
     }
-    const defaultProviderID = config.opencode.model.provider;
-    const defaultModelID = config.opencode.model.modelId;
-    if (!defaultProviderID || !defaultModelID) {
-        return false;
+    lines.push(t("model.menu.recent_title"));
+    if (modelLists.recent.length === 0) {
+        lines.push(t("model.menu.recent_empty"));
     }
-    return models[0].providerID === defaultProviderID && models[0].modelID === defaultModelID;
+    return lines.join("\n");
 }
 /**
  * Handle model selection callback
@@ -91,27 +90,30 @@ export async function handleModelSelect(ctx) {
     }
 }
 /**
- * Build inline keyboard with favorite models
+ * Build inline keyboard with favorite and recent models
  * @param currentModel Current model for highlighting
  * @returns InlineKeyboard with model selection buttons
  */
-export async function buildModelSelectionMenu(currentModel, favoriteModels) {
+export async function buildModelSelectionMenu(currentModel, modelLists) {
     const keyboard = new InlineKeyboard();
-    const favorites = favoriteModels ?? (await getFavoriteModels());
-    if (favorites.length === 0) {
-        logger.warn("[ModelHandler] No favorite models found");
+    const lists = modelLists ?? (await getModelSelectionLists());
+    const favorites = lists.favorites;
+    const recent = lists.recent;
+    if (favorites.length === 0 && recent.length === 0) {
+        logger.warn("[ModelHandler] No model choices found in favorites/recent");
         return keyboard;
     }
-    // Add button for each favorite model
-    favorites.forEach((model) => {
+    const addButton = (model, prefix) => {
         const isActive = currentModel &&
             model.providerID === currentModel.providerID &&
             model.modelID === currentModel.modelID;
         // Inline buttons use full model ID without truncation
-        const label = `${model.providerID}/${model.modelID}`;
+        const label = `${prefix} ${model.providerID}/${model.modelID}`;
         const labelWithCheck = isActive ? `✅ ${label}` : label;
         keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
-    });
+    };
+    favorites.forEach((model) => addButton(model, "⭐"));
+    recent.forEach((model) => addButton(model, "🕘"));
     return keyboard;
 }
 /**
@@ -121,22 +123,18 @@ export async function buildModelSelectionMenu(currentModel, favoriteModels) {
 export async function showModelSelectionMenu(ctx) {
     try {
         const currentModel = fetchCurrentModel();
-        const favorites = await getFavoriteModels();
-        const keyboard = await buildModelSelectionMenu(currentModel, favorites);
+        const modelLists = await getModelSelectionLists();
+        const keyboard = await buildModelSelectionMenu(currentModel, modelLists);
         if (keyboard.inline_keyboard.length === 0) {
             await ctx.reply(t("model.menu.empty"));
             return;
         }
-        const displayName = formatModelForDisplay(currentModel.providerID, currentModel.modelID);
-        const text = t("model.menu.current", { name: displayName });
+        const text = buildModelSelectionMenuText(modelLists);
         await replyWithInlineMenu(ctx, {
             menuKind: "model",
             text,
             keyboard,
         });
-        if (isOnlyConfigDefaultModel(favorites)) {
-            await ctx.reply(t("model.menu.favorites_hint"));
-        }
     }
     catch (err) {
         logger.error("[ModelHandler] Error showing model menu:", err);

package/dist/bot/handlers/voice.js

@@ -80,7 +80,10 @@ async function downloadTelegramFile(ctx, fileId) {
         logger.debug(`[Voice] Downloading file: ${file.file_path} (${file.file_size ?? "?"} bytes)`);
         const buffer = await downloadTelegramFileByUrl(fileUrl);
         // Extract filename from file_path (e.g., "voice/file_123.oga" -> "file_123.oga")
-        const filename = file.file_path.split("/").pop() || "audio.ogg";
+        let filename = file.file_path.split("/").pop() || "audio.ogg";
+        if (filename.endsWith(".oga")) {
+            filename = filename.slice(0, -4) + ".ogg";
+        }
         logger.debug(`[Voice] Downloaded file: ${filename} (${buffer.length} bytes)`);
         return { buffer, filename };
     }

package/dist/bot/message-patterns.js

@@ -1,3 +1,3 @@
-export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s.+$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s[\s\S]+$/;
 // Keep support for both legacy "💭" and current "💡" prefix.
 export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/i18n/de.js

@@ -70,14 +70,23 @@ export const de = {
     "projects.empty": "📭 Keine Projekte gefunden.\n\nÖffne ein Verzeichnis in OpenCode und erstelle mindestens eine Sitzung, dann erscheint es hier.",
     "projects.select": "Projekt auswählen:",
     "projects.select_with_current": "Projekt auswählen:\n\nAktuell: 🏗 {project}",
+    "projects.page_indicator": "Seite {current}/{total}",
+    "projects.prev_page": "⬅️ Zurück",
+    "projects.next_page": "Weiter ➡️",
     "projects.fetch_error": "🔴 OpenCode-Server ist nicht verfügbar oder beim Laden der Projekte ist ein Fehler aufgetreten.",
+    "projects.page_load_error": "Diese Seite konnte nicht geladen werden. Bitte versuche es erneut.",
     "projects.selected": "✅ Projekt ausgewählt: {project}\n\n📋 Sitzung wurde zurückgesetzt. Nutze /sessions oder /new für dieses Projekt.",
     "projects.select_error": "🔴 Projekt konnte nicht ausgewählt werden.",
     "sessions.project_not_selected": "🏗 Projekt ist nicht ausgewählt.\n\nWähle zuerst ein Projekt mit /projects.",
     "sessions.empty": "📭 Keine Sitzungen gefunden.\n\nErstelle eine neue Sitzung mit /new.",
     "sessions.select": "Sitzung auswählen:",
+    "sessions.select_page": "Sitzung auswählen (Seite {page}):",
     "sessions.fetch_error": "🔴 OpenCode-Server ist nicht verfügbar oder beim Laden der Sitzungen ist ein Fehler aufgetreten.",
     "sessions.select_project_first": "🔴 Projekt ist nicht ausgewählt. Nutze /projects.",
+    "sessions.page_empty_callback": "Auf dieser Seite gibt es keine Sitzungen",
+    "sessions.page_load_error_callback": "Diese Seite kann nicht geladen werden. Bitte versuche es erneut.",
+    "sessions.button.prev_page": "⬅️ Zurück",
+    "sessions.button.next_page": "Weiter ➡️",
     "sessions.loading_context": "⏳ Lade Kontext und letzte Nachrichten...",
     "sessions.selected": "✅ Sitzung ausgewählt: {title}",
     "sessions.select_error": "🔴 Sitzung konnte nicht ausgewählt werden.",
@@ -115,12 +124,19 @@ export const de = {
     "agent.change_error_callback": "Modus konnte nicht geändert werden",
     "agent.menu.current": "Aktueller Modus: {name}\n\nModus auswählen:",
     "agent.menu.select": "Arbeitsmodus auswählen:",
+    "agent.menu.empty": "⚠️ Keine verfügbaren Agenten",
+    "agent.menu.error": "🔴 Agentenliste konnte nicht geladen werden",
     "model.changed_callback": "Modell geändert: {name}",
     "model.changed_message": "✅ Modell geändert zu: {name}",
     "model.change_error_callback": "Modell konnte nicht geändert werden",
     "model.menu.empty": "⚠️ Keine verfügbaren Modelle",
+    "model.menu.select": "Modell auswählen:",
     "model.menu.current": "Aktuelles Modell: {name}\n\nModell auswählen:",
-    "model.menu.favorites_hint": "ℹ️ Die Modellliste wird aus Favoriten in OpenCode CLI erstellt.",
+    "model.menu.favorites_title": "⭐ Favoriten (Füge Modelle in OpenCode CLI zu den Favoriten hinzu)",
+    "model.menu.favorites_empty": "— Leer.",
+    "model.menu.recent_title": "🕘 Zuletzt verwendet",
+    "model.menu.recent_empty": "— Leer.",
+    "model.menu.favorites_hint": "ℹ️ Füge Modelle in OpenCode CLI zu den Favoriten hinzu, damit sie oben angezeigt werden.",
     "model.menu.error": "🔴 Modellliste konnte nicht geladen werden",
     "variant.model_not_selected_callback": "Fehler: Modell ist nicht ausgewählt",
     "variant.changed_callback": "Variante geändert: {name}",

package/dist/i18n/en.js

@@ -70,14 +70,23 @@ export const en = {
     "projects.empty": "📭 No projects found.\n\nOpen a directory in OpenCode and create at least one session, then it will appear here.",
     "projects.select": "Select a project:",
     "projects.select_with_current": "Select a project:\n\nCurrent: 🏗 {project}",
+    "projects.page_indicator": "Page {current}/{total}",
+    "projects.prev_page": "⬅️ Previous",
+    "projects.next_page": "Next ➡️",
     "projects.fetch_error": "🔴 OpenCode Server is unavailable or an error occurred while loading projects.",
+    "projects.page_load_error": "Cannot load this page. Please try again.",
     "projects.selected": "✅ Project selected: {project}\n\n📋 Session was reset. Use /sessions or /new for this project.",
     "projects.select_error": "🔴 Failed to select project.",
     "sessions.project_not_selected": "🏗 Project is not selected.\n\nFirst select a project with /projects.",
     "sessions.empty": "📭 No sessions found.\n\nCreate a new session with /new.",
     "sessions.select": "Select a session:",
+    "sessions.select_page": "Select a session (page {page}):",
     "sessions.fetch_error": "🔴 OpenCode Server is unavailable or an error occurred while loading sessions.",
     "sessions.select_project_first": "🔴 Project is not selected. Use /projects.",
+    "sessions.page_empty_callback": "No sessions on this page",
+    "sessions.page_load_error_callback": "Cannot load this page. Please try again.",
+    "sessions.button.prev_page": "⬅️ Prev",
+    "sessions.button.next_page": "Next ➡️",
     "sessions.loading_context": "⏳ Loading context and latest messages...",
     "sessions.selected": "✅ Session selected: {title}",
     "sessions.select_error": "🔴 Failed to select session.",
@@ -115,12 +124,19 @@ export const en = {
     "agent.change_error_callback": "Failed to change mode",
     "agent.menu.current": "Current mode: {name}\n\nSelect mode:",
     "agent.menu.select": "Select work mode:",
+    "agent.menu.empty": "⚠️ No available agents",
+    "agent.menu.error": "🔴 Failed to get agents list",
     "model.changed_callback": "Model changed: {name}",
     "model.changed_message": "✅ Model changed to: {name}",
     "model.change_error_callback": "Failed to change model",
     "model.menu.empty": "⚠️ No available models",
+    "model.menu.select": "Select model:",
     "model.menu.current": "Current model: {name}\n\nSelect model:",
-    "model.menu.favorites_hint": "ℹ️ The model list is built from favorites in OpenCode CLI.",
+    "model.menu.favorites_title": "⭐ Favorites (Add models to favorites in OpenCode CLI)",
+    "model.menu.favorites_empty": "— Empty.",
+    "model.menu.recent_title": "🕘 Recent",
+    "model.menu.recent_empty": "— Empty.",
+    "model.menu.favorites_hint": "ℹ️ Add models to favorites in OpenCode CLI to keep them at the top.",
     "model.menu.error": "🔴 Failed to get models list",
     "variant.model_not_selected_callback": "Error: model is not selected",
     "variant.changed_callback": "Variant changed: {name}",

package/dist/i18n/es.js

@@ -70,14 +70,23 @@ export const es = {
     "projects.empty": "📭 No se encontraron proyectos.\n\nAbre un directorio en OpenCode y crea al menos una sesión; entonces aparecerá aquí.",
     "projects.select": "Selecciona un proyecto:",
     "projects.select_with_current": "Selecciona un proyecto:\n\nActual: 🏗 {project}",
+    "projects.page_indicator": "Página {current}/{total}",
+    "projects.prev_page": "⬅️ Anterior",
+    "projects.next_page": "Siguiente ➡️",
     "projects.fetch_error": "🔴 OpenCode Server no está disponible u ocurrió un error al cargar los proyectos.",
+    "projects.page_load_error": "No se puede cargar esta página. Inténtalo de nuevo.",
     "projects.selected": "✅ Proyecto seleccionado: {project}\n\n📋 La sesión se reinició. Usa /sessions o /new para este proyecto.",
     "projects.select_error": "🔴 No se pudo seleccionar el proyecto.",
     "sessions.project_not_selected": "🏗 No hay un proyecto seleccionado.\n\nPrimero selecciona un proyecto con /projects.",
     "sessions.empty": "📭 No se encontraron sesiones.\n\nCrea una sesión nueva con /new.",
     "sessions.select": "Selecciona una sesión:",
+    "sessions.select_page": "Selecciona una sesión (página {page}):",
     "sessions.fetch_error": "🔴 OpenCode Server no está disponible u ocurrió un error al cargar las sesiones.",
     "sessions.select_project_first": "🔴 No hay un proyecto seleccionado. Usa /projects.",
+    "sessions.page_empty_callback": "No hay sesiones en esta página",
+    "sessions.page_load_error_callback": "No se puede cargar esta página. Inténtalo de nuevo.",
+    "sessions.button.prev_page": "⬅️ Anterior",
+    "sessions.button.next_page": "Siguiente ➡️",
     "sessions.loading_context": "⏳ Cargando contexto y los últimos mensajes...",
     "sessions.selected": "✅ Sesión seleccionada: {title}",
     "sessions.select_error": "🔴 No se pudo seleccionar la sesión.",
@@ -115,12 +124,19 @@ export const es = {
     "agent.change_error_callback": "No se pudo cambiar el modo",
     "agent.menu.current": "Modo actual: {name}\n\nSelecciona el modo:",
     "agent.menu.select": "Selecciona el modo de trabajo:",
+    "agent.menu.empty": "⚠️ No hay agentes disponibles",
+    "agent.menu.error": "🔴 No se pudo obtener la lista de agentes",
     "model.changed_callback": "Modelo cambiado: {name}",
     "model.changed_message": "✅ Modelo cambiado a: {name}",
     "model.change_error_callback": "No se pudo cambiar el modelo",
     "model.menu.empty": "⚠️ No hay modelos disponibles",
+    "model.menu.select": "Selecciona el modelo:",
     "model.menu.current": "Modelo actual: {name}\n\nSelecciona el modelo:",
-    "model.menu.favorites_hint": "ℹ️ La lista de modelos se genera a partir de favoritos en OpenCode CLI.",
+    "model.menu.favorites_title": "⭐ Favoritos (Agrega modelos a favoritos en OpenCode CLI)",
+    "model.menu.favorites_empty": "— Vacío.",
+    "model.menu.recent_title": "🕘 Recientes",
+    "model.menu.recent_empty": "— Vacío.",
+    "model.menu.favorites_hint": "ℹ️ Agrega modelos a favoritos en OpenCode CLI para mantenerlos arriba de la lista.",
     "model.menu.error": "🔴 No se pudo obtener la lista de modelos",
     "variant.model_not_selected_callback": "Error: no hay un modelo seleccionado",
     "variant.changed_callback": "Variante cambiada: {name}",

package/dist/i18n/ru.js

@@ -70,14 +70,23 @@ export const ru = {
     "projects.empty": "📭 Проектов нет.\n\nОткройте директорию в OpenCode и создайте хотя бы одну сессию, после этого она появится здесь.",
     "projects.select": "Выберите проект:",
     "projects.select_with_current": "Выберите проект:\n\nТекущий: 🏗 {project}",
+    "projects.page_indicator": "Страница {current}/{total}",
+    "projects.prev_page": "⬅️ Назад",
+    "projects.next_page": "Вперёд ➡️",
     "projects.fetch_error": "🔴 OpenCode Server недоступен или произошла ошибка при получении списка проектов.",
+    "projects.page_load_error": "Не удалось загрузить эту страницу. Попробуйте снова.",
     "projects.selected": "✅ Проект выбран: {project}\n\n📋 Сессия сброшена. Используйте /sessions или /new для работы с этим проектом.",
     "projects.select_error": "🔴 Ошибка при выборе проекта.",
     "sessions.project_not_selected": "🏗 Проект не выбран.\n\nСначала выберите проект командой /projects.",
     "sessions.empty": "📭 Сессий нет.\n\nСоздайте новую сессию командой /new.",
     "sessions.select": "Выберите сессию:",
+    "sessions.select_page": "Выберите сессию (страница {page}):",
     "sessions.fetch_error": "🔴 OpenCode Server недоступен или произошла ошибка при получении списка сессий.",
     "sessions.select_project_first": "🔴 Проект не выбран. Используйте /projects.",
+    "sessions.page_empty_callback": "На этой странице нет сессий",
+    "sessions.page_load_error_callback": "Не удалось загрузить эту страницу. Пожалуйста, попробуйте снова.",
+    "sessions.button.prev_page": "⬅️ Назад",
+    "sessions.button.next_page": "Вперёд ➡️",
     "sessions.loading_context": "⏳ Загружаю контекст и последние сообщения...",
     "sessions.selected": "✅ Сессия выбрана: {title}",
     "sessions.select_error": "🔴 Ошибка при выборе сессии.",
@@ -115,12 +124,19 @@ export const ru = {
     "agent.change_error_callback": "Ошибка при смене режима",
     "agent.menu.current": "Текущий режим: {name}\n\nВыберите режим:",
     "agent.menu.select": "Выберите режим работы:",
+    "agent.menu.empty": "⚠️ Нет доступных агентов",
+    "agent.menu.error": "🔴 Не удалось получить список агентов",
     "model.changed_callback": "Модель изменена: {name}",
     "model.changed_message": "✅ Модель изменена на: {name}",
     "model.change_error_callback": "Ошибка при смене модели",
     "model.menu.empty": "⚠️ Нет доступных моделей",
+    "model.menu.select": "Выберите модель:",
     "model.menu.current": "Текущая модель: {name}\n\nВыберите модель:",
-    "model.menu.favorites_hint": "ℹ️ Список моделей формируется из favorites в OpenCode CLI.",
+    "model.menu.favorites_title": "⭐ Избранное (Добавляйте модели в избранное через OpenCode CLI)",
+    "model.menu.favorites_empty": "— Список пуст.",
+    "model.menu.recent_title": "🕘 Недавние",
+    "model.menu.recent_empty": "— Список пуст.",
+    "model.menu.favorites_hint": "ℹ️ Добавляйте модели в избранное через OpenCode CLI, чтобы они были вверху списка.",
     "model.menu.error": "🔴 Не удалось получить список моделей",
     "variant.model_not_selected_callback": "Ошибка: модель не выбрана",
     "variant.changed_callback": "Вариант изменен: {name}",

package/dist/i18n/zh.js

@@ -70,14 +70,23 @@ export const zh = {
     "projects.empty": "📭 未找到项目。\n\n在 OpenCode 中打开一个目录并至少创建一个会话，然后它会出现在这里。",
     "projects.select": "请选择一个项目：",
     "projects.select_with_current": "请选择一个项目：\n\n当前：🏗 {project}",
+    "projects.page_indicator": "第 {current}/{total} 页",
+    "projects.prev_page": "⬅️ 上一页",
+    "projects.next_page": "下一页 ➡️",
     "projects.fetch_error": "🔴 OpenCode 服务器不可用，或加载项目时发生错误。",
+    "projects.page_load_error": "无法加载此页面。请重试。",
     "projects.selected": "✅ 已选择项目：{project}\n\n📋 会话已重置。请在此项目中使用 /sessions 或 /new。",
     "projects.select_error": "🔴 选择项目失败。",
     "sessions.project_not_selected": "🏗 未选择项目。\n\n请先使用 /projects 选择一个项目。",
     "sessions.empty": "📭 未找到会话。\n\n使用 /new 创建新会话。",
     "sessions.select": "请选择一个会话：",
+    "sessions.select_page": "请选择一个会话（第 {page} 页）：",
     "sessions.fetch_error": "🔴 OpenCode 服务器不可用，或加载会话时发生错误。",
     "sessions.select_project_first": "🔴 未选择项目。使用 /projects。",
+    "sessions.page_empty_callback": "这一页没有会话",
+    "sessions.page_load_error_callback": "无法加载此页面。请重试。",
+    "sessions.button.prev_page": "⬅️ 上一页",
+    "sessions.button.next_page": "下一页 ➡️",
     "sessions.loading_context": "⏳ 正在加载上下文和最新消息...",
     "sessions.selected": "✅ 已选择会话：{title}",
     "sessions.select_error": "🔴 选择会话失败。",
@@ -115,12 +124,19 @@ export const zh = {
     "agent.change_error_callback": "切换模式失败",
     "agent.menu.current": "当前模式：{name}\n\n请选择模式：",
     "agent.menu.select": "请选择工作模式：",
+    "agent.menu.empty": "⚠️ 没有可用的代理",
+    "agent.menu.error": "🔴 获取代理列表失败",
     "model.changed_callback": "模型已更改：{name}",
     "model.changed_message": "✅ 模型已切换为：{name}",
     "model.change_error_callback": "切换模型失败",
     "model.menu.empty": "⚠️ 没有可用模型",
+    "model.menu.select": "请选择模型：",
     "model.menu.current": "当前模型：{name}\n\n请选择模型：",
-    "model.menu.favorites_hint": "ℹ️ 模型列表来自 OpenCode CLI 的收藏（favorites）。",
+    "model.menu.favorites_title": "⭐ 收藏（可在 OpenCode CLI 中将模型加入收藏）",
+    "model.menu.favorites_empty": "— 列表为空。",
+    "model.menu.recent_title": "🕘 最近使用",
+    "model.menu.recent_empty": "— 列表为空。",
+    "model.menu.favorites_hint": "ℹ️ 可在 OpenCode CLI 中将模型加入收藏，使其显示在列表顶部。",
     "model.menu.error": "🔴 获取模型列表失败",
     "variant.model_not_selected_callback": "错误：未选择模型",
     "variant.changed_callback": "变体已更改：{name}",

package/dist/model/manager.js

@@ -34,6 +34,20 @@ function normalizeFavoriteModels(state) {
         modelID: model.modelID,
     }));
 }
+function normalizeRecentModels(state) {
+    if (!Array.isArray(state.recent)) {
+        return [];
+    }
+    return state.recent
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
 function getOpenCodeModelStatePath() {
     const xdgStateHome = process.env.XDG_STATE_HOME;
     if (xdgStateHome && xdgStateHome.trim().length > 0) {
@@ -43,38 +57,54 @@ function getOpenCodeModelStatePath() {
     return path.join(homeDir, ".local", "state", "opencode", "model.json");
 }
 /**
- * Get list of favorite models from OpenCode local state file
- * Falls back to env default model if file is unavailable or empty
+ * Get favorite and recent models from OpenCode local state file.
+ * Config model is always treated as favorite.
  */
-export async function getFavoriteModels() {
+export async function getModelSelectionLists() {
     const envDefaultModel = getEnvDefaultModel();
     try {
         const fs = await import("fs/promises");
         const stateFilePath = getOpenCodeModelStatePath();
         const content = await fs.readFile(stateFilePath, "utf-8");
         const state = JSON.parse(content);
-        const favorites = normalizeFavoriteModels(state);
+        const rawFavorites = normalizeFavoriteModels(state);
+        const favorites = envDefaultModel
+            ? dedupeModels([...rawFavorites, envDefaultModel])
+            : rawFavorites;
+        if (rawFavorites.length === 0 && envDefaultModel) {
+            logger.info(`[ModelManager] No favorites in ${stateFilePath}, using config model as favorite`);
+        }
         if (favorites.length === 0) {
-            if (envDefaultModel) {
-                logger.info(`[ModelManager] No favorites in ${stateFilePath}, using env default model`);
-                return [envDefaultModel];
-            }
             logger.warn(`[ModelManager] No favorites in ${stateFilePath}`);
-            return [];
         }
-        const merged = envDefaultModel ? dedupeModels([...favorites, envDefaultModel]) : favorites;
-        logger.debug(`[ModelManager] Loaded ${merged.length} favorite models from ${stateFilePath}`);
-        return merged;
+        const favoriteKeys = new Set(favorites.map((model) => `${model.providerID}/${model.modelID}`));
+        const recent = dedupeModels(normalizeRecentModels(state)).filter((model) => !favoriteKeys.has(`${model.providerID}/${model.modelID}`));
+        logger.debug(`[ModelManager] Loaded model selection lists from ${stateFilePath}: favorites=${favorites.length}, recent=${recent.length}`);
+        return { favorites, recent };
     }
     catch (err) {
         if (envDefaultModel) {
-            logger.warn("[ModelManager] Failed to load OpenCode favorites, using env default model:", err);
-            return [envDefaultModel];
+            logger.warn("[ModelManager] Failed to load OpenCode model state, using config model as favorite:", err);
+            return {
+                favorites: [envDefaultModel],
+                recent: [],
+            };
         }
-        logger.error("[ModelManager] Failed to load OpenCode favorites:", err);
-        return [];
+        logger.error("[ModelManager] Failed to load OpenCode model state:", err);
+        return {
+            favorites: [],
+            recent: [],
+        };
     }
 }
+/**
+ * Get list of favorite models from OpenCode local state file
+ * Falls back to env default model if file is unavailable or empty
+ */
+export async function getFavoriteModels() {
+    const { favorites } = await getModelSelectionLists();
+    return favorites;
+}
 /**
  * Get current model from settings or fallback to config
  * @returns Current model info

package/dist/model/types.js

@@ -8,12 +8,10 @@
  * @returns Formatted string "providerID/modelID"
  */
 export function formatModelForButton(providerID, modelID) {
-    const formatted = `${providerID}/${modelID}`;
-    // Limit to ~30 characters for button width (excluding emoji)
-    if (formatted.length > 30) {
-        return `🤖 ${formatted.substring(0, 27)}...`;
-    }
-    return `🤖 ${formatted}`;
+    // If model name is too long, we only truncate the model part
+    const displayModelId = modelID.length > 20 ? `${modelID.substring(0, 17)}...` : modelID;
+    const displayProviderId = providerID.length > 15 ? `${providerID.substring(0, 12)}...` : providerID;
+    return `🤖 ${displayProviderId}\n${displayModelId}`;
 }
 /**
  * Format model for display in messages (full format)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",