@grinev/opencode-telegram-bot 0.22.1 → 0.22.3

package/dist/bot/callbacks/model-selection-callback-handler.js

@@ -1,6 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { getStoredAgent, resolveProjectAgent } from "../../app/services/agent-selection-service.js";
-import { searchModels, selectModel, } from "../../app/services/model-selection-service.js";
+import { searchModels, selectModel } from "../../app/services/model-selection-service.js";
 import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
 import { formatModelForDisplay } from "../../app/types/model.js";
 import { interactionManager } from "../../app/managers/interaction-manager.js";
@@ -10,7 +10,28 @@ import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
 import { keyboardManager } from "../keyboards/keyboard-manager.js";
 import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu } from "../menus/inline-menu.js";
-import { MODEL_SEARCH_AGAIN_CALLBACK, MODEL_SEARCH_CALLBACK, MODEL_SEARCH_CANCEL_CALLBACK, } from "../menus/model-selection-menu.js";
+import { MODEL_LIST_CALLBACK_PREFIX, MODEL_SEARCH_AGAIN_CALLBACK, MODEL_SEARCH_CALLBACK, MODEL_SEARCH_CANCEL_CALLBACK, } from "../menus/model-selection-menu.js";
+const MODEL_SEARCH_RESULT_CALLBACK_PREFIX = "model:result:";
+function parseModelItems(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (typeof item !== "object" ||
+            item === null ||
+            !("providerID" in item) ||
+            !("modelID" in item)) {
+            return [];
+        }
+        const providerID = item.providerID;
+        const modelID = item.modelID;
+        if (typeof providerID !== "string" || typeof modelID !== "string") {
+            return [];
+        }
+        const variant = "variant" in item && typeof item.variant === "string" ? item.variant : "default";
+        return [{ providerID, modelID, variant }];
+    });
+}
 function parseModelSearchMetadata() {
     const state = interactionManager.getSnapshot();
     if (!state || state.kind !== "custom") {
@@ -22,7 +43,84 @@ function parseModelSearchMetadata() {
         return null;
     }
     const messageId = typeof state.metadata.messageId === "number" ? state.metadata.messageId : undefined;
-    return { flow, stage, messageId };
+    return { flow, stage, messageId, models: parseModelItems(state.metadata.models) };
+}
+function parseModelListMetadata() {
+    const state = interactionManager.getSnapshot();
+    if (!state || state.kind !== "inline" || state.metadata.menuKind !== "model") {
+        return null;
+    }
+    const modelLists = state.metadata.modelLists;
+    if (typeof modelLists !== "object" || modelLists === null) {
+        return null;
+    }
+    return {
+        favorites: parseModelItems("favorites" in modelLists ? modelLists.favorites : undefined),
+        recent: parseModelItems("recent" in modelLists ? modelLists.recent : undefined),
+    };
+}
+function parseNonNegativeIndex(value) {
+    if (!/^\d+$/.test(value)) {
+        return null;
+    }
+    const index = Number.parseInt(value, 10);
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+function parseCallbackIndex(data, prefix) {
+    if (!data.startsWith(prefix)) {
+        return null;
+    }
+    return parseNonNegativeIndex(data.slice(prefix.length));
+}
+function resolveModelListCallback(data) {
+    if (!data.startsWith(MODEL_LIST_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const parts = data.slice(MODEL_LIST_CALLBACK_PREFIX.length).split(":");
+    if (parts.length !== 2) {
+        return null;
+    }
+    const [kind, indexText] = parts;
+    const index = parseNonNegativeIndex(indexText);
+    if ((kind !== "favorites" && kind !== "recent") || index === null) {
+        return null;
+    }
+    const lists = parseModelListMetadata();
+    if (!lists) {
+        return null;
+    }
+    const model = kind === "favorites" ? lists.favorites[index] : lists.recent[index];
+    if (!model) {
+        return null;
+    }
+    return {
+        providerID: model.providerID,
+        modelID: model.modelID,
+        variant: "default",
+    };
+}
+function parseLegacyModelCallback(data) {
+    const parts = data.split(":");
+    if (parts.length < 3) {
+        return null;
+    }
+    const providerID = parts[1];
+    const modelID = parts.slice(2).join(":");
+    if (!providerID || !modelID) {
+        return null;
+    }
+    return {
+        providerID,
+        modelID,
+        variant: "default",
+    };
+}
+function isShortModelCallback(data) {
+    return (data.startsWith(MODEL_SEARCH_RESULT_CALLBACK_PREFIX) ||
+        data.startsWith(MODEL_LIST_CALLBACK_PREFIX));
 }
 /**
  * Shared logic for applying a model selection and updating UI.
@@ -75,23 +173,17 @@ export async function handleModelSelect(ctx) {
     }
     logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
     try {
-        // Parse callback data: "model:providerID:modelID"
-        const parts = callbackQuery.data.split(":");
-        if (parts.length < 3) {
+        const modelInfo = resolveModelListCallback(callbackQuery.data);
+        const shouldUseLegacyFallback = !isShortModelCallback(callbackQuery.data);
+        const resolvedModelInfo = modelInfo ?? (shouldUseLegacyFallback ? parseLegacyModelCallback(callbackQuery.data) : null);
+        if (!resolvedModelInfo) {
             logger.error(`[ModelHandler] Invalid callback data format: ${callbackQuery.data}`);
             clearActiveInlineMenu("model_select_invalid_callback");
             await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
             return true;
         }
-        const providerID = parts[1];
-        const modelID = parts.slice(2).join(":"); // Handle model IDs that may contain ":"
-        const modelInfo = {
-            providerID,
-            modelID,
-            variant: "default",
-        };
         clearActiveInlineMenu("model_selected");
-        await applyModelSelectionAndNotify(ctx, modelInfo);
+        await applyModelSelectionAndNotify(ctx, resolvedModelInfo);
         return true;
     }
     catch (err) {
@@ -150,9 +242,9 @@ export async function handleModelSearchTextInput(ctx) {
     try {
         const results = await searchModels(text);
         const keyboard = new InlineKeyboard();
-        for (const model of results) {
+        for (const [index, model] of results.entries()) {
             const label = `${model.providerID}/${model.modelID}`;
-            keyboard.text(label, `model:${model.providerID}:${model.modelID}`).row();
+            keyboard.text(label, `${MODEL_SEARCH_RESULT_CALLBACK_PREFIX}${index}`).row();
         }
         keyboard.row();
         keyboard.text(t("model.search.search_again"), MODEL_SEARCH_AGAIN_CALLBACK);
@@ -168,6 +260,11 @@ export async function handleModelSearchTextInput(ctx) {
                 flow: "model-search",
                 stage: "results",
                 messageId: sent.message_id,
+                models: results.map((model) => ({
+                    providerID: model.providerID,
+                    modelID: model.modelID,
+                    variant: "default",
+                })),
             },
         });
         return true;
@@ -225,19 +322,28 @@ export async function handleModelSearchResults(ctx) {
         logger.debug("[ModelHandler] Model search prompt shown (search again)");
         return true;
     }
-    // Model selection from search results
+    const resultIndex = parseCallbackIndex(data, MODEL_SEARCH_RESULT_CALLBACK_PREFIX);
+    if (resultIndex !== null) {
+        const modelInfo = meta.models[resultIndex];
+        if (!modelInfo) {
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
+        }
+        interactionManager.clear("model_search_selected");
+        await applyModelSelectionAndNotify(ctx, modelInfo);
+        return true;
+    }
+    // Backward compatibility for callbacks from already-rendered search result messages.
     if (data.startsWith("model:")) {
-        const parts = data.split(":");
-        if (parts.length < 3) {
+        if (isShortModelCallback(data)) {
+            logger.error(`[ModelHandler] Invalid search result callback data: ${data}`);
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
+        }
+        const modelInfo = parseLegacyModelCallback(data);
+        if (!modelInfo) {
             return true;
         }
-        const providerID = parts[1];
-        const modelID = parts.slice(2).join(":");
-        const modelInfo = {
-            providerID,
-            modelID,
-            variant: "default",
-        };
         interactionManager.clear("model_search_selected");
         await applyModelSelectionAndNotify(ctx, modelInfo);
         return true;

package/dist/bot/callbacks/permission-callback-handler.js

@@ -18,6 +18,19 @@ function getCallbackMessageId(ctx) {
 function isPermissionReply(value) {
     return value === "once" || value === "always" || value === "reject";
 }
+function isPermissionRequestNotFound(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const candidate = error;
+    if (candidate._tag === "PermissionNotFoundError") {
+        return true;
+    }
+    if (candidate.name === "NotFoundError") {
+        return true;
+    }
+    return [candidate.message, candidate.data?.message].some((message) => typeof message === "string" && message.toLowerCase().includes("permission request not found"));
+}
 export async function handlePermissionCallback(ctx) {
     const data = ctx.callbackQuery?.data;
     if (!data)
@@ -36,8 +49,8 @@ export async function handlePermissionCallback(ctx) {
         await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
         return true;
     }
-    const requestID = permissionManager.getRequestID(callbackMessageId);
-    if (!requestID) {
+    const requestIDs = permissionManager.getRequestIDs(callbackMessageId);
+    if (requestIDs.length === 0) {
         await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
         return true;
     }
@@ -51,7 +64,7 @@ export async function handlePermissionCallback(ctx) {
         return true;
     }
     try {
-        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
+        await handlePermissionReply(ctx, action, requestIDs, callbackMessageId);
     }
     catch (err) {
         logger.error("[PermissionHandler] Error handling callback:", err);
@@ -62,7 +75,7 @@ export async function handlePermissionCallback(ctx) {
     }
     return true;
 }
-async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
+async function handlePermissionReply(ctx, reply, requestIDs, callbackMessageId) {
     const currentProject = getCurrentProject();
     const currentSession = getCurrentSession();
     const chatId = ctx.chat?.id;
@@ -84,16 +97,36 @@ async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
     await ctx.answerCallbackQuery({ text: replyLabels[reply] });
     await ctx.deleteMessage().catch(() => { });
     summaryAggregator.stopTypingIndicator();
-    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestID=${requestID}`);
+    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestIDs=${requestIDs.join(",")}`);
     safeBackgroundTask({
         taskName: "permission.reply",
-        task: () => opencodeClient.permission.reply({
-            requestID,
-            directory,
-            reply,
-        }),
+        task: async () => {
+            let firstError = null;
+            let lastResponse = null;
+            for (const requestID of requestIDs) {
+                const response = await opencodeClient.permission.reply({
+                    requestID,
+                    directory,
+                    reply,
+                });
+                lastResponse = response;
+                if (!response.error) {
+                    continue;
+                }
+                if (requestIDs.length > 1 && isPermissionRequestNotFound(response.error)) {
+                    logger.debug(`[PermissionHandler] Ignoring duplicate permission reply miss: requestID=${requestID}`);
+                    continue;
+                }
+                firstError ??= response.error;
+            }
+            return { ...lastResponse, error: firstError };
+        },
         onSuccess: ({ error }) => {
             if (error) {
+                if (isPermissionRequestNotFound(error)) {
+                    logger.debug(`[PermissionHandler] Permission request already resolved: requestIDs=${requestIDs.join(",")}`);
+                    return;
+                }
                 logger.error("[PermissionHandler] Failed to send permission reply:", error);
                 if (ctx.api && chatId) {
                     void ctx.api.sendMessage(chatId, t("permission.send_reply_error")).catch(() => { });
@@ -109,6 +142,6 @@ async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
         return;
     }
     syncPermissionInteractionState({
-        lastRepliedRequestID: requestID,
+        lastRepliedRequestIDs: requestIDs,
     });
 }

package/dist/bot/commands/status-command.js

@@ -38,7 +38,7 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.mode", { mode: agentDisplay })}\n`;
         // Add model information
         const currentModel = fetchCurrentModel();
-        const modelDisplay = `🤖 ${currentModel.providerID}/${currentModel.modelID}`;
+        const modelDisplay = `🧠 ${currentModel.providerID}/${currentModel.modelID}`;
         message += `${t("status.line.model", { model: modelDisplay })}\n`;
         const currentProject = getCurrentProject();
         if (currentProject) {

package/dist/bot/handlers/document-handler.js

@@ -1,10 +1,12 @@
 import { config } from "../../config.js";
 import { processUserPrompt } from "./prompt.js";
 import { downloadTelegramFile, toDataUri, isTextMimeType, isFileSizeAllowed, } from "../../app/services/file-download-service.js";
+import { isDocExtractorConfigured, extractDocument } from "../../app/services/document-extractor-service.js";
 import { getModelCapabilities, supportsInput } from "../../app/services/model-capabilities-service.js";
 import { getStoredModel } from "../../app/services/model-selection-service.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { flushPendingPrompt } from "./message-merger.js";
 export async function handleDocumentMessage(ctx, deps) {
     const downloadFile = deps.downloadFile ?? downloadTelegramFile;
     const getCapabilities = deps.getModelCapabilities ?? getModelCapabilities;
@@ -14,6 +16,7 @@ export async function handleDocumentMessage(ctx, deps) {
     if (!doc) {
         return;
     }
+    flushPendingPrompt(ctx.chat.id);
     const caption = ctx.message.caption || "";
     const mimeType = doc.mime_type || "";
     const filename = doc.file_name || "document";
@@ -56,14 +59,48 @@ export async function handleDocumentMessage(ctx, deps) {
             await processPrompt(ctx, caption, deps, [filePart]);
             return;
         }
-        if (mimeType === "application/pdf") {
+        const DOCUMENT_MIME_TYPES = [
+            "application/pdf",
+            "application/msword",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "application/vnd.ms-powerpoint",
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.oasis.opendocument.text",
+            "application/vnd.oasis.opendocument.presentation",
+            "application/vnd.oasis.opendocument.spreadsheet",
+            "text/rtf",
+        ];
+        if (DOCUMENT_MIME_TYPES.includes(mimeType)) {
             const storedModel = getStored();
             const capabilities = await getCapabilities(storedModel.providerID, storedModel.modelID);
             if (!supportsInput(capabilities, "pdf")) {
-                logger.warn(`[Document] Model ${storedModel.providerID}/${storedModel.modelID} doesn't support PDF input`);
-                await ctx.reply(t("bot.model_no_pdf"));
-                if (caption.trim().length > 0) {
-                    await processPrompt(ctx, caption, deps);
+                if (isDocExtractorConfigured()) {
+                    logger.warn(`[Document] Model doesn't support PDF input, delegating document to DOC_EXTRACTOR_URL`);
+                    await ctx.reply(t("bot.file_downloading"));
+                    const downloadedFile = await downloadFile(ctx.api, doc.file_id);
+                    try {
+                        const result = await extractDocument(downloadedFile.buffer, mimeType, filename);
+                        const promptWithFile = `--- Content of ${filename} ---\n${result.text}\n--- End of file ---\n\n${caption}`;
+                        logger.info(`[Document] Sending extracted document text from ${filename} (${result.text.length} chars) as prompt`);
+                        await processPrompt(ctx, promptWithFile, deps);
+                    }
+                    catch (extractErr) {
+                        const errMsg = extractErr instanceof Error ? extractErr.message : String(extractErr);
+                        logger.error(`[Document] Document extraction failed: ${errMsg}`);
+                        await ctx.reply(t("bot.document_extraction_error"));
+                        if (caption.trim().length > 0) {
+                            await processPrompt(ctx, caption, deps);
+                        }
+                    }
+                }
+                else {
+                    logger.warn(`[Document] Model doesn't support PDF input and DOC_EXTRACTOR_URL is not configured`);
+                    await ctx.reply(t("bot.model_no_pdf"));
+                    if (caption.trim().length > 0) {
+                        await processPrompt(ctx, caption, deps);
+                    }
                 }
                 return;
             }
@@ -76,7 +113,7 @@ export async function handleDocumentMessage(ctx, deps) {
                 filename: filename,
                 url: dataUri,
             };
-            logger.info(`[Document] Sending PDF (${downloadedFile.buffer.length} bytes, ${filename}) with prompt`);
+            logger.info(`[Document] Sending document (${downloadedFile.buffer.length} bytes, ${filename}, ${mimeType}) with prompt`);
             await processPrompt(ctx, caption, deps, [filePart]);
             return;
         }

package/dist/bot/handlers/media-group-handler.js

@@ -5,6 +5,7 @@ import { getStoredModel } from "../../app/services/model-selection-service.js";
 import { logger } from "../../utils/logger.js";
 import { downloadTelegramFile, isFileSizeAllowed, isTextMimeType, toDataUri, } from "../../app/services/file-download-service.js";
 import { processUserPrompt } from "./prompt.js";
+import { flushPendingPrompt } from "./message-merger.js";
 const DEFAULT_MEDIA_GROUP_DEBOUNCE_MS = 1_000;
 export class MediaGroupAttachmentHandler {
     deps;
@@ -26,6 +27,7 @@ export class MediaGroupAttachmentHandler {
             await next();
             return;
         }
+        flushPendingPrompt(chatId);
         const key = this.getBatchKey(chatId, mediaGroupId);
         const existingBatch = this.batches.get(key);
         if (existingBatch) {

package/dist/bot/handlers/message-merger.js

@@ -0,0 +1,65 @@
+import { processUserPrompt } from "./prompt.js";
+import { logger } from "../../utils/logger.js";
+const TELEGRAM_SPLIT_CHUNK_MIN_LENGTH = 4000;
+// Buffered plain-text prompts, keyed by chat id. Telegram delivers one long
+// message (or one paste) as several consecutive updates; merging them here
+// turns those chunks into a single OpenCode prompt.
+const pendingByChat = new Map();
+function flushPending(chatId) {
+    const pending = pendingByChat.get(chatId);
+    if (!pending) {
+        return;
+    }
+    pendingByChat.delete(chatId);
+    clearTimeout(pending.timer);
+    const { texts, ctx, deps } = pending;
+    if (texts.length > 1) {
+        logger.info(`[Bot] Merging ${texts.length} quick consecutive messages into one prompt (chatId=${chatId}, totalLength=${texts.reduce((sum, part) => sum + part.length, 0)})`);
+    }
+    else {
+        logger.debug(`[Bot] Flushing single pending prompt (chatId=${chatId})`);
+    }
+    void processUserPrompt(ctx, texts.join("\n\n"), deps).catch((err) => {
+        logger.error(`[Bot] Failed to process merged prompt (chatId=${chatId})`, err);
+    });
+}
+/**
+ * Buffers a near-limit plain-text prompt so Telegram-split chunks are merged
+ * into a single OpenCode prompt. Short messages are processed immediately
+ * unless they follow a buffered chunk. Each new chunk restarts the wait window.
+ *
+ * Pass `mergeWindowMs <= 0` to disable merging and process the message
+ * immediately.
+ */
+export function queuePromptForMerging(ctx, text, deps, mergeWindowMs) {
+    const chatId = ctx.chat.id;
+    const existing = pendingByChat.get(chatId);
+    if (mergeWindowMs <= 0 || (!existing && text.length < TELEGRAM_SPLIT_CHUNK_MIN_LENGTH)) {
+        void processUserPrompt(ctx, text, deps).catch((err) => {
+            logger.error(`[Bot] Failed to process prompt (chatId=${chatId})`, err);
+        });
+        return;
+    }
+    if (existing) {
+        existing.texts.push(text);
+        existing.ctx = ctx;
+        clearTimeout(existing.timer);
+        existing.timer = setTimeout(() => flushPending(chatId), mergeWindowMs);
+        logger.debug(`[Bot] Appended message to pending prompt (chatId=${chatId}, parts=${existing.texts.length})`);
+        return;
+    }
+    const timer = setTimeout(() => flushPending(chatId), mergeWindowMs);
+    pendingByChat.set(chatId, { texts: [text], ctx, deps, timer });
+    logger.debug(`[Bot] Started prompt merge window (chatId=${chatId}, mergeWindowMs=${mergeWindowMs})`);
+}
+/** Immediately flush any buffered prompt for the chat (e.g. when a command arrives). */
+export function flushPendingPrompt(chatId) {
+    flushPending(chatId);
+}
+/** Test helper: clears all buffered prompts and their timers. */
+export function __resetMessageMergerForTests() {
+    for (const pending of pendingByChat.values()) {
+        clearTimeout(pending.timer);
+    }
+    pendingByChat.clear();
+}

package/dist/bot/handlers/photo-handler.js

@@ -3,12 +3,14 @@ import { getModelCapabilities, supportsInput } from "../../app/services/model-ca
 import { getStoredModel } from "../../app/services/model-selection-service.js";
 import { t } from "../../i18n/index.js";
 import { logger } from "../../utils/logger.js";
+import { flushPendingPrompt } from "./message-merger.js";
 import { processUserPrompt } from "./prompt.js";
 export async function handlePhotoMessage(ctx, deps) {
     const photos = ctx.message?.photo;
     if (!photos || photos.length === 0) {
         return;
     }
+    flushPendingPrompt(ctx.chat.id);
     const caption = ctx.message.caption || "";
     const largestPhoto = photos[photos.length - 1];
     const downloadFile = deps.downloadFile ?? downloadTelegramFile;

package/dist/bot/handlers/voice-handler.js

@@ -7,6 +7,7 @@ import { config } from "../../config.js";
 import { getTtsMode } from "../../app/stores/settings-store.js";
 import { isSttConfigured, transcribeAudio, } from "../../app/services/stt-service.js";
 import { processUserPrompt } from "./prompt.js";
+import { flushPendingPrompt } from "./message-merger.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { buildTelegramFileUrl } from "../../app/services/file-download-service.js";
@@ -131,6 +132,7 @@ export async function handleVoiceMessage(ctx, deps) {
         logger.warn("[Voice] Received voice/audio message with no file_id");
         return;
     }
+    flushPendingPrompt(ctx.chat.id);
     // Check if STT is configured
     if (!sttConfigured()) {
         await ctx.reply(t("stt.not_configured"));

package/dist/bot/menus/inline-menu.js

@@ -71,6 +71,7 @@ export async function replyWithInlineMenu(ctx, options) {
         kind: "inline",
         expectedInput: "callback",
         metadata: {
+            ...options.metadata,
             menuKind: options.menuKind,
             messageId: message.message_id,
         },

package/dist/bot/menus/model-selection-menu.js

@@ -6,6 +6,10 @@ import { replyWithInlineMenu } from "./inline-menu.js";
 export const MODEL_SEARCH_CALLBACK = "model:search";
 export const MODEL_SEARCH_AGAIN_CALLBACK = "model:search:again";
 export const MODEL_SEARCH_CANCEL_CALLBACK = "model:search:cancel";
+export const MODEL_LIST_CALLBACK_PREFIX = "model:list:";
+export function buildModelListCallback(kind, index) {
+    return `${MODEL_LIST_CALLBACK_PREFIX}${kind}:${index}`;
+}
 function buildModelSelectionMenuText(modelLists) {
     const lines = [t("model.menu.select"), t("model.menu.favorites_title")];
     if (modelLists.favorites.length === 0) {
@@ -31,16 +35,16 @@ export async function buildModelSelectionMenu(currentModel, modelLists) {
         logger.warn("[ModelHandler] No model choices found in favorites/recent");
         return keyboard;
     }
-    const addButton = (model, prefix) => {
+    const addButton = (model, prefix, kind, index) => {
         const isActive = currentModel &&
             model.providerID === currentModel.providerID &&
             model.modelID === currentModel.modelID;
         const label = `${prefix} ${model.providerID}/${model.modelID}`;
         const labelWithCheck = isActive ? `✅ ${label}` : label;
-        keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
+        keyboard.text(labelWithCheck, buildModelListCallback(kind, index)).row();
     };
-    favorites.forEach((model) => addButton(model, "⭐"));
-    recent.forEach((model) => addButton(model, "🕘"));
+    favorites.forEach((model, index) => addButton(model, "⭐", "favorites", index));
+    recent.forEach((model, index) => addButton(model, "🕘", "recent", index));
     return keyboard;
 }
 /**
@@ -57,6 +61,7 @@ export async function showModelSelectionMenu(ctx) {
             menuKind: "model",
             text,
             keyboard,
+            metadata: { modelLists },
         });
     }
     catch (err) {

package/dist/bot/menus/permission-menu.js

@@ -67,8 +67,31 @@ export function syncPermissionInteractionState(metadata = {}) {
 /**
  * Show permission request message with inline buttons
  */
-export async function showPermissionRequest(bot, chatId, request) {
+export async function showPermissionRequest(bot, chatId, request, generation = permissionManager.getGeneration()) {
     logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
+    if (generation !== permissionManager.getGeneration() ||
+        permissionManager.isResolved(request.id)) {
+        logger.debug(`[PermissionHandler] Skipping stale or already resolved request: ${request.id}`);
+        return;
+    }
+    const grouped = permissionManager.addEquivalentRequest(request, generation);
+    if (grouped) {
+        // Re-render the visible prompt so the user can see the answer will apply
+        // to more than one pending request.
+        await bot
+            .editMessageText(chatId, grouped.messageId, formatPermissionText(grouped.request, grouped.count), { reply_markup: buildPermissionKeyboard() })
+            .catch((err) => {
+            logger.warn("[PermissionHandler] Failed to update grouped permission message:", err);
+        });
+        syncPermissionInteractionState({
+            requestID: request.id,
+            messageId: grouped.messageId,
+            deduplicated: true,
+            groupedCount: grouped.count,
+        });
+        summaryAggregator.stopTypingIndicator();
+        return;
+    }
     const text = formatPermissionText(request);
     const keyboard = buildPermissionKeyboard();
     try {
@@ -76,7 +99,12 @@ export async function showPermissionRequest(bot, chatId, request) {
             reply_markup: keyboard,
         });
         logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
-        permissionManager.startPermission(request, message.message_id);
+        if (!permissionManager.startPermission(request, message.message_id, generation)) {
+            await bot.deleteMessage(chatId, message.message_id).catch((err) => {
+                logger.warn(`[PermissionHandler] Failed to delete stale permission message:`, err);
+            });
+            return;
+        }
         syncPermissionInteractionState({
             requestID: request.id,
             messageId: message.message_id,
@@ -91,7 +119,7 @@ export async function showPermissionRequest(bot, chatId, request) {
 /**
  * Format permission request text
  */
-function formatPermissionText(request) {
+function formatPermissionText(request, groupedCount = 1) {
     const emoji = PERMISSION_EMOJIS[request.permission] || "🔐";
     const nameKey = PERMISSION_NAME_KEYS[request.permission];
     const name = nameKey ? t(nameKey) : request.permission;
@@ -102,6 +130,9 @@ function formatPermissionText(request) {
             text += `• ${pattern}\n`;
         });
     }
+    if (groupedCount > 1) {
+        text += t("permission.grouped_count", { count: groupedCount });
+    }
     return text;
 }
 /**

package/dist/bot/message-patterns.js

@@ -1,4 +1,4 @@
 export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\s(?:Mode|Agent)$/;
-export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\s(?:Mode|Agent)$)[\s\S]+$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🧠\s(?!.*\s(?:Mode|Agent)$)[\s\S]+$/;
 // Keep support for both legacy "💭" and current "💡" prefix.
 export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;