@grinev/opencode-telegram-bot 0.20.5 → 0.21.0

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

@@ -0,0 +1,220 @@
+import { config } from "../../config.js";
+import { t } from "../../i18n/index.js";
+import { getModelCapabilities, supportsInput } from "../../model/capabilities.js";
+import { getStoredModel } from "../../model/manager.js";
+import { logger } from "../../utils/logger.js";
+import { downloadTelegramFile, isFileSizeAllowed, isTextMimeType, toDataUri, } from "../utils/file-download.js";
+import { processUserPrompt } from "./prompt.js";
+const DEFAULT_MEDIA_GROUP_DEBOUNCE_MS = 1_000;
+export class MediaGroupAttachmentHandler {
+    deps;
+    debounceMs;
+    batches = new Map();
+    constructor(deps, options = {}) {
+        this.deps = deps;
+        this.debounceMs = options.debounceMs ?? DEFAULT_MEDIA_GROUP_DEBOUNCE_MS;
+    }
+    async handle(ctx, next) {
+        const item = this.createPendingItem(ctx);
+        if (!item) {
+            await next();
+            return;
+        }
+        const mediaGroupId = ctx.message?.media_group_id;
+        const chatId = ctx.chat?.id;
+        if (!mediaGroupId || chatId === undefined) {
+            await next();
+            return;
+        }
+        const key = this.getBatchKey(chatId, mediaGroupId);
+        const existingBatch = this.batches.get(key);
+        if (existingBatch) {
+            clearTimeout(existingBatch.timer);
+            existingBatch.items.push(item);
+            existingBatch.timer = this.createFlushTimer(key);
+            return;
+        }
+        this.batches.set(key, {
+            items: [item],
+            timer: this.createFlushTimer(key),
+        });
+    }
+    async flushAll() {
+        const keys = Array.from(this.batches.keys());
+        await Promise.all(keys.map((key) => this.flushBatch(key)));
+    }
+    createPendingItem(ctx) {
+        const message = ctx.message;
+        const mediaGroupId = message?.media_group_id;
+        if (!message || !mediaGroupId || !ctx.chat) {
+            return null;
+        }
+        const baseItem = {
+            ctx,
+            messageId: message.message_id,
+            caption: message.caption || "",
+        };
+        if (message.photo && message.photo.length > 0) {
+            return {
+                ...baseItem,
+                kind: "photo",
+                photos: message.photo,
+            };
+        }
+        if (message.document) {
+            return {
+                ...baseItem,
+                kind: "document",
+                document: message.document,
+            };
+        }
+        return {
+            ...baseItem,
+            kind: "unsupported",
+        };
+    }
+    getBatchKey(chatId, mediaGroupId) {
+        return `${chatId}:${mediaGroupId}`;
+    }
+    createFlushTimer(key) {
+        return setTimeout(() => {
+            void this.flushBatch(key);
+        }, this.debounceMs);
+    }
+    async flushBatch(key) {
+        const batch = this.batches.get(key);
+        if (!batch) {
+            return;
+        }
+        clearTimeout(batch.timer);
+        this.batches.delete(key);
+        const items = [...batch.items].sort((left, right) => left.messageId - right.messageId);
+        const replyCtx = items[0]?.ctx;
+        if (!replyCtx) {
+            return;
+        }
+        logger.info(`[MediaGroup] Processing Telegram media group: key=${key}, items=${items.length}`);
+        try {
+            const validationResult = await this.validateItems(items);
+            if ("reason" in validationResult) {
+                logger.warn(`[MediaGroup] Rejecting media group: key=${key}, reason=${validationResult.reason}`);
+                await replyCtx.reply(t("bot.media_group_not_processed"));
+                return;
+            }
+            await replyCtx.reply(t("bot.files_downloading"));
+            const { promptText, fileParts } = await this.preparePrompt(validationResult.items, items);
+            const processPrompt = this.deps.processPrompt ?? processUserPrompt;
+            logger.info(`[MediaGroup] Sending media group as one prompt: key=${key}, files=${fileParts.length}, textLength=${promptText.length}`);
+            await processPrompt(replyCtx, promptText, this.deps, fileParts);
+        }
+        catch (err) {
+            logger.error(`[MediaGroup] Failed to process media group: key=${key}`, err);
+            await replyCtx.reply(t("bot.media_group_download_error"));
+        }
+    }
+    async validateItems(items) {
+        const storedModel = (this.deps.getStoredModel ?? getStoredModel)();
+        const validItems = [];
+        let needsImageSupport = false;
+        let needsPdfSupport = false;
+        for (const item of items) {
+            if (item.kind === "unsupported") {
+                return { reason: "unsupported_media_kind" };
+            }
+            if (item.kind === "photo") {
+                needsImageSupport = true;
+                const largestPhoto = item.photos[item.photos.length - 1];
+                validItems.push({
+                    kind: "file",
+                    ctx: item.ctx,
+                    messageId: item.messageId,
+                    fileId: largestPhoto.file_id,
+                    mime: "image/jpeg",
+                    filename: `photo-${item.messageId}.jpg`,
+                });
+                continue;
+            }
+            const document = item.document;
+            const mimeType = document.mime_type || "";
+            const filename = document.file_name || "document";
+            if (isTextMimeType(mimeType)) {
+                if (!isFileSizeAllowed(document.file_size, config.files.maxFileSizeKb)) {
+                    return { reason: "text_file_too_large" };
+                }
+                validItems.push({
+                    kind: "text",
+                    ctx: item.ctx,
+                    fileId: document.file_id,
+                    filename,
+                });
+                continue;
+            }
+            if (mimeType.startsWith("image/")) {
+                needsImageSupport = true;
+                validItems.push({
+                    kind: "file",
+                    ctx: item.ctx,
+                    messageId: item.messageId,
+                    fileId: document.file_id,
+                    mime: mimeType,
+                    filename,
+                });
+                continue;
+            }
+            if (mimeType === "application/pdf") {
+                needsPdfSupport = true;
+                validItems.push({
+                    kind: "file",
+                    ctx: item.ctx,
+                    messageId: item.messageId,
+                    fileId: document.file_id,
+                    mime: mimeType,
+                    filename,
+                });
+                continue;
+            }
+            return { reason: `unsupported_document_mime:${mimeType || "unknown"}` };
+        }
+        if (needsImageSupport || needsPdfSupport) {
+            const getCapabilities = this.deps.getModelCapabilities ?? getModelCapabilities;
+            const capabilities = await getCapabilities(storedModel.providerID, storedModel.modelID);
+            if (needsImageSupport && !supportsInput(capabilities, "image")) {
+                return { reason: `model_no_image:${storedModel.providerID}/${storedModel.modelID}` };
+            }
+            if (needsPdfSupport && !supportsInput(capabilities, "pdf")) {
+                return { reason: `model_no_pdf:${storedModel.providerID}/${storedModel.modelID}` };
+            }
+        }
+        return { items: validItems };
+    }
+    async preparePrompt(validItems, originalItems) {
+        const downloadFile = this.deps.downloadFile ?? downloadTelegramFile;
+        const textSections = [];
+        const fileParts = [];
+        for (const item of validItems) {
+            const downloadedFile = await downloadFile(item.ctx.api, item.fileId);
+            if (item.kind === "text") {
+                const textContent = downloadedFile.buffer.toString("utf-8");
+                textSections.push(`--- Content of ${item.filename} ---\n${textContent}\n--- End of file ---`);
+                continue;
+            }
+            fileParts.push({
+                type: "file",
+                mime: item.mime,
+                filename: item.filename,
+                url: toDataUri(downloadedFile.buffer, item.mime),
+            });
+        }
+        const captions = originalItems
+            .map((item) => item.caption.trim())
+            .filter((caption) => caption.length > 0);
+        return {
+            promptText: [...textSections, ...captions].join("\n\n"),
+            fileParts,
+        };
+    }
+}
+export function createMediaGroupAttachmentMiddleware(deps, options = {}) {
+    const handler = new MediaGroupAttachmentHandler(deps, options);
+    return (ctx, next) => handler.handle(ctx, next);
+}

package/dist/bot/handlers/model.js

@@ -1,5 +1,5 @@
 import { InlineKeyboard } from "grammy";
-import { selectModel, fetchCurrentModel, getModelSelectionLists } from "../../model/manager.js";
+import { selectModel, fetchCurrentModel, getModelSelectionLists, searchModels, } from "../../model/manager.js";
 import { formatModelForDisplay } from "../../model/types.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { logger } from "../../utils/logger.js";
@@ -8,7 +8,11 @@ import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { interactionManager } from "../../interaction/manager.js";
 import { t } from "../../i18n/index.js";
+const MODEL_SEARCH_CALLBACK = "model:search";
+const MODEL_SEARCH_AGAIN_CALLBACK = "model:search:again";
+const MODEL_SEARCH_CANCEL_CALLBACK = "model:search:cancel";
 function buildModelSelectionMenuText(modelLists) {
     const lines = [t("model.menu.select"), t("model.menu.favorites_title")];
     if (modelLists.favorites.length === 0) {
@@ -20,9 +24,51 @@ function buildModelSelectionMenuText(modelLists) {
     }
     return lines.join("\n");
 }
+function parseModelSearchMetadata() {
+    const state = interactionManager.getSnapshot();
+    if (!state || state.kind !== "custom") {
+        return null;
+    }
+    const flow = state.metadata.flow;
+    const stage = state.metadata.stage;
+    if (flow !== "model-search" || typeof stage !== "string") {
+        return null;
+    }
+    const messageId = typeof state.metadata.messageId === "number" ? state.metadata.messageId : undefined;
+    return { flow, stage, messageId };
+}
 /**
- * Handle model selection callback
- * @param ctx grammY context
+ * Shared logic for applying a model selection and updating UI.
+ * Used by both the regular inline menu flow and the search results flow.
+ */
+async function applyModelSelectionAndNotify(ctx, modelInfo) {
+    if (ctx.chat) {
+        keyboardManager.initialize(ctx.api, ctx.chat.id);
+    }
+    selectModel(modelInfo);
+    keyboardManager.updateModel(modelInfo);
+    await pinnedMessageManager.refreshContextLimit();
+    const currentAgent = await resolveProjectAgent(getStoredAgent());
+    const contextInfo = pinnedMessageManager.getContextInfo() ??
+        (pinnedMessageManager.getContextLimit() > 0
+            ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+            : null);
+    keyboardManager.updateAgent(currentAgent);
+    if (contextInfo) {
+        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+    }
+    const variantName = formatVariantForButton(modelInfo.variant || "default");
+    const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName);
+    const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
+    await ctx.answerCallbackQuery({ text: t("model.changed_callback", { name: displayName }) });
+    await ctx.reply(t("model.changed_message", { name: displayName }), {
+        reply_markup: keyboard,
+    });
+    await ctx.deleteMessage().catch(() => { });
+}
+/**
+ * Handle model selection callback from the inline menu.
+ * Skips search-related callbacks (handled separately).
  * @returns true if handled, false otherwise
  */
 export async function handleModelSelect(ctx) {
@@ -30,15 +76,18 @@ export async function handleModelSelect(ctx) {
     if (!callbackQuery?.data || !callbackQuery.data.startsWith("model:")) {
         return false;
     }
+    // Skip search callbacks — handled by handleModelSearchCallback / handleModelSearchResults
+    if (callbackQuery.data === MODEL_SEARCH_CALLBACK ||
+        callbackQuery.data === MODEL_SEARCH_AGAIN_CALLBACK ||
+        callbackQuery.data === MODEL_SEARCH_CANCEL_CALLBACK) {
+        return false;
+    }
     const isActiveMenu = await ensureActiveInlineMenu(ctx, "model");
     if (!isActiveMenu) {
         return true;
     }
     logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
     try {
-        if (ctx.chat) {
-            keyboardManager.initialize(ctx.api, ctx.chat.id);
-        }
         // Parse callback data: "model:providerID:modelID"
         const parts = callbackQuery.data.split(":");
         if (parts.length < 3) {
@@ -52,35 +101,10 @@ export async function handleModelSelect(ctx) {
         const modelInfo = {
             providerID,
             modelID,
-            variant: "default", // Reset to default when switching models
+            variant: "default",
         };
-        // Select model and persist
-        selectModel(modelInfo);
-        // Update keyboard manager state (may not be initialized if no session selected)
-        keyboardManager.updateModel(modelInfo);
-        // Refresh context limit for new model
-        await pinnedMessageManager.refreshContextLimit();
-        // Update Reply Keyboard with new model and context
-        const currentAgent = await resolveProjectAgent(getStoredAgent());
-        const contextInfo = pinnedMessageManager.getContextInfo() ??
-            (pinnedMessageManager.getContextLimit() > 0
-                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
-                : null);
-        keyboardManager.updateAgent(currentAgent);
-        if (contextInfo) {
-            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
-        }
-        const variantName = formatVariantForButton(modelInfo.variant || "default");
-        const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName);
-        const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
         clearActiveInlineMenu("model_selected");
-        // Send confirmation message with updated keyboard
-        await ctx.answerCallbackQuery({ text: t("model.changed_callback", { name: displayName }) });
-        await ctx.reply(t("model.changed_message", { name: displayName }), {
-            reply_markup: keyboard,
-        });
-        // Delete the inline menu message
-        await ctx.deleteMessage().catch(() => { });
+        await applyModelSelectionAndNotify(ctx, modelInfo);
         return true;
     }
     catch (err) {
@@ -91,15 +115,15 @@ export async function handleModelSelect(ctx) {
     }
 }
 /**
- * Build inline keyboard with favorite and recent models
- * @param currentModel Current model for highlighting
- * @returns InlineKeyboard with model selection buttons
+ * Build inline keyboard with favorite and recent models, plus a search button at the top.
  */
 export async function buildModelSelectionMenu(currentModel, modelLists) {
     const keyboard = new InlineKeyboard();
     const lists = modelLists ?? (await getModelSelectionLists());
     const favorites = lists.favorites;
     const recent = lists.recent;
+    // Search button — always present as first row
+    keyboard.text(t("model.search.button"), MODEL_SEARCH_CALLBACK).row();
     if (favorites.length === 0 && recent.length === 0) {
         logger.warn("[ModelHandler] No model choices found in favorites/recent");
         return keyboard;
@@ -108,7 +132,6 @@ export async function buildModelSelectionMenu(currentModel, modelLists) {
         const isActive = currentModel &&
             model.providerID === currentModel.providerID &&
             model.modelID === currentModel.modelID;
-        // Inline buttons use full model ID without truncation
         const label = `${prefix} ${model.providerID}/${model.modelID}`;
         const labelWithCheck = isActive ? `✅ ${label}` : label;
         keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
@@ -119,17 +142,13 @@ export async function buildModelSelectionMenu(currentModel, modelLists) {
 }
 /**
  * Show model selection menu
- * @param ctx grammY context
  */
 export async function showModelSelectionMenu(ctx) {
     try {
         const currentModel = fetchCurrentModel();
         const modelLists = await getModelSelectionLists();
         const keyboard = await buildModelSelectionMenu(currentModel, modelLists);
-        if (keyboard.inline_keyboard.length === 0) {
-            await ctx.reply(t("model.menu.empty"));
-            return;
-        }
+        // keyboard always has at least the search button, so length > 0
         const text = buildModelSelectionMenuText(modelLists);
         await replyWithInlineMenu(ctx, {
             menuKind: "model",
@@ -142,3 +161,147 @@ export async function showModelSelectionMenu(ctx) {
         await ctx.reply(t("model.menu.error"));
     }
 }
+// ─── Model search handlers ────────────────────────────────────────────────
+/**
+ * Handle the search button callback (model:search) from the inline menu.
+ * Transitions the interaction to text-input mode and prompts the user.
+ */
+export async function handleModelSearchCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data) {
+        return false;
+    }
+    if (data !== MODEL_SEARCH_CALLBACK) {
+        return false;
+    }
+    const isActive = await ensureActiveInlineMenu(ctx, "model");
+    if (!isActive) {
+        return true;
+    }
+    await ctx.answerCallbackQuery().catch(() => { });
+    await ctx.deleteMessage().catch(() => { });
+    // Start a new interaction for search text input
+    // interactionManager.start() clears any existing interaction automatically
+    interactionManager.start({
+        kind: "custom",
+        expectedInput: "text",
+        metadata: {
+            flow: "model-search",
+            stage: "input",
+        },
+    });
+    await ctx.reply(t("model.search.prompt"));
+    logger.debug("[ModelHandler] Model search prompt shown");
+    return true;
+}
+/**
+ * Handle text input for model search.
+ * Searches the full provider catalog and shows results (or "not found").
+ */
+export async function handleModelSearchTextInput(ctx) {
+    const meta = parseModelSearchMetadata();
+    if (!meta || meta.stage !== "input") {
+        return false;
+    }
+    const text = ctx.message?.text;
+    if (!text) {
+        return false;
+    }
+    logger.debug(`[ModelHandler] Model search query: "${text}"`);
+    try {
+        const results = await searchModels(text);
+        const keyboard = new InlineKeyboard();
+        for (const model of results) {
+            const label = `${model.providerID}/${model.modelID}`;
+            keyboard.text(label, `model:${model.providerID}:${model.modelID}`).row();
+        }
+        keyboard.row();
+        keyboard.text(t("model.search.search_again"), MODEL_SEARCH_AGAIN_CALLBACK);
+        keyboard.text(t("inline.button.cancel"), MODEL_SEARCH_CANCEL_CALLBACK);
+        const replyText = results.length === 0
+            ? t("model.search.no_results", { query: text })
+            : t("model.search.results_title", { query: text });
+        const sent = await ctx.reply(replyText, { reply_markup: keyboard });
+        // Transition to results stage (callback-only)
+        interactionManager.transition({
+            expectedInput: "callback",
+            metadata: {
+                flow: "model-search",
+                stage: "results",
+                messageId: sent.message_id,
+            },
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error("[ModelHandler] Model search error:", err);
+        await ctx.reply(t("model.search.error"));
+        interactionManager.clear("model_search_error");
+        return true;
+    }
+}
+/**
+ * Handle callbacks from the search results menu:
+ * - model:search:cancel — clears interaction, deletes message
+ * - model:search:again — delegates to handleModelSearchCallback
+ * - model:provider:model — selects the model from search results
+ */
+export async function handleModelSearchResults(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data) {
+        return false;
+    }
+    const meta = parseModelSearchMetadata();
+    if (!meta || meta.stage !== "results") {
+        return false;
+    }
+    // Verify message ID matches to reject stale callbacks
+    const callbackMessageId = ctx.callbackQuery?.message?.message_id;
+    if (meta.messageId !== undefined && callbackMessageId !== meta.messageId) {
+        await ctx
+            .answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true })
+            .catch(() => { });
+        return true;
+    }
+    // Cancel
+    if (data === MODEL_SEARCH_CANCEL_CALLBACK) {
+        interactionManager.clear("model_search_cancelled");
+        await ctx.answerCallbackQuery({ text: t("inline.cancelled_callback") }).catch(() => { });
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    // Search again — inline implementation
+    if (data === MODEL_SEARCH_AGAIN_CALLBACK) {
+        await ctx.answerCallbackQuery().catch(() => { });
+        await ctx.deleteMessage().catch(() => { });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "text",
+            metadata: {
+                flow: "model-search",
+                stage: "input",
+            },
+        });
+        await ctx.reply(t("model.search.prompt"));
+        logger.debug("[ModelHandler] Model search prompt shown (search again)");
+        return true;
+    }
+    // Model selection from search results
+    if (data.startsWith("model:")) {
+        const parts = data.split(":");
+        if (parts.length < 3) {
+            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;
+    }
+    return false;
+}

package/dist/bot/handlers/prompt.js

@@ -167,7 +167,8 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         if (parts.length === 0 || (parts.length > 0 && parts.every((p) => p.type === "file"))) {
             if (fileParts.length > 0) {
                 // Files without text - add a minimal system prompt
-                parts.unshift({ type: "text", text: "See attached file" });
+                const attachmentText = fileParts.length === 1 ? "See attached file" : "See attached files";
+                parts.unshift({ type: "text", text: attachmentText });
             }
         }
         const promptOptions = {

package/dist/bot/index.js

@@ -25,13 +25,14 @@ import { renameCommand, handleRenameCancel, handleRenameTextAnswer } from "./com
 import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands/task.js";
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
+import { handleMessagesCallback, messagesCommand } from "./commands/messages.js";
 import { skillsCommand, handleSkillsCallback, handleSkillTextArguments, } from "./commands/skills.js";
 import { mcpsCommand, handleMcpsCallback } from "./commands/mcps.js";
 import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
 import { handleAgentSelect, showAgentSelectionMenu } from "./handlers/agent.js";
-import { handleModelSelect, showModelSelectionMenu } from "./handlers/model.js";
+import { handleModelSelect, handleModelSearchCallback, handleModelSearchResults, handleModelSearchTextInput, showModelSelectionMenu, } from "./handlers/model.js";
 import { handleVariantSelect, showVariantSelectionMenu } from "./handlers/variant.js";
 import { handleContextButtonPress, handleCompactConfirm } from "./handlers/context.js";
 import { handleInlineMenuCancel } from "./handlers/inline-menu.js";
@@ -57,8 +58,9 @@ import { createTelegramBotOptions } from "./telegram-client-options.js";
 import { clearPromptResponseMode, processUserPrompt } from "./handlers/prompt.js";
 import { handleVoiceMessage } from "./handlers/voice.js";
 import { handleDocumentMessage } from "./handlers/document.js";
+import { createMediaGroupAttachmentMiddleware } from "./handlers/media-group.js";
 import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
-import { reconcileBusyState } from "./utils/busy-reconciliation.js";
+import { reconcileBusyState, setResponseStreamerForReconciliation } from "./utils/busy-reconciliation.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
 import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
@@ -217,6 +219,7 @@ const responseStreamer = new ResponseStreamer({
         });
     },
 });
+setResponseStreamerForReconciliation(responseStreamer);
 const toolCallStreamer = new ToolCallStreamer({
     throttleMs: RESPONSE_STREAM_THROTTLE_MS,
     sendText: async (sessionId, text) => {
@@ -593,14 +596,16 @@ async function ensureEventSubscription(directory) {
             return;
         }
         const currentSession = getCurrentSession();
-        if (!currentSession || currentSession.id !== request.sessionID) {
+        const isCurrent = currentSession?.id === request.sessionID;
+        const isSubagent = summaryAggregator.isSubagentSession(request.sessionID);
+        if (!currentSession || (!isCurrent && !isSubagent)) {
             return;
         }
         await Promise.all([
             toolMessageBatcher.flushSession(request.sessionID, "permission_asked"),
             toolCallStreamer.flushSession(request.sessionID, "permission_asked"),
         ]);
-        logger.info(`[Bot] Received permission request from agent: type=${request.permission}, requestID=${request.id}`);
+        logger.info(`[Bot] Received permission request from agent: type=${request.permission}, requestID=${request.id}, subagent=${isSubagent}`);
         await showPermissionRequest(botInstance.api, chatIdInstance, request);
     });
     summaryAggregator.setOnThinking(async (sessionId) => {
@@ -925,6 +930,7 @@ export function createBot() {
     bot.command("open", openCommand);
     bot.command("ls", lsCommand);
     bot.command("sessions", sessionsCommand);
+    bot.command("messages", messagesCommand);
     bot.command("new", (ctx) => newCommand(ctx, { bot, ensureEventSubscription }));
     bot.command("abort", abortCommand);
     bot.command("detach", detachCommand);
@@ -961,6 +967,8 @@ export function createBot() {
             const handledQuestion = await handleQuestionCallback(ctx);
             const handledPermission = await handlePermissionCallback(ctx);
             const handledAgent = await handleAgentSelect(ctx);
+            const handledModelSearch = await handleModelSearchCallback(ctx);
+            const handledModelSearchResults = await handleModelSearchResults(ctx);
             const handledModel = await handleModelSelect(ctx);
             const handledVariant = await handleVariantSelect(ctx);
             const handledCompactConfirm = await handleCompactConfirm(ctx);
@@ -968,9 +976,10 @@ export function createBot() {
             const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
+            const handledMessages = await handleMessagesCallback(ctx, { bot, ensureEventSubscription });
             const handledSkills = await handleSkillsCallback(ctx, { bot, ensureEventSubscription });
             const handledMcps = await handleMcpsCallback(ctx);
-            logger.debug(`[Bot] Callback handled: backgroundSession=${handledBackgroundSession}, inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, ls=${handledLs}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}, mcps=${handledMcps}`);
+            logger.debug(`[Bot] Callback handled: backgroundSession=${handledBackgroundSession}, inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, ls=${handledLs}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, modelSearch=${handledModelSearch}, modelSearchResults=${handledModelSearchResults}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, messages=${handledMessages}, skills=${handledSkills}, mcps=${handledMcps}`);
             if (!handledBackgroundSession &&
                 !handledInlineCancel &&
                 !handledSession &&
@@ -981,6 +990,8 @@ export function createBot() {
                 !handledQuestion &&
                 !handledPermission &&
                 !handledAgent &&
+                !handledModelSearch &&
+                !handledModelSearchResults &&
                 !handledModel &&
                 !handledVariant &&
                 !handledCompactConfirm &&
@@ -988,6 +999,7 @@ export function createBot() {
                 !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands &&
+                !handledMessages &&
                 !handledSkills &&
                 !handledMcps) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
@@ -1103,6 +1115,7 @@ export function createBot() {
         chatIdInstance = ctx.chat.id;
         await handleVoiceMessage(ctx, voicePromptDeps);
     });
+    bot.on("message", createMediaGroupAttachmentMiddleware({ bot, ensureEventSubscription }));
     // Photo message handler
     bot.on("message:photo", async (ctx) => {
         logger.debug(`[Bot] Received photo message, chatId=${ctx.chat.id}`);
@@ -1179,6 +1192,10 @@ export function createBot() {
         if (handledTask) {
             return;
         }
+        const handledModelSearchText = await handleModelSearchTextInput(ctx);
+        if (handledModelSearchText) {
+            return;
+        }
         const handledRename = await handleRenameTextAnswer(ctx);
         if (handledRename) {
             return;