@grinev/opencode-telegram-bot 0.20.6 → 0.21.1

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/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";
@@ -59,12 +60,12 @@ 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";
 import { shouldSuppressUserAbortSessionError } from "./utils/abort-error-suppression.js";
-import { editRenderedBotPart, getTelegramRenderedPartSignature, sendRenderedBotPart, } from "./utils/telegram-text.js";
+import { completeDraftPart, editRenderedBotPart, getTelegramRenderedPartSignature, sendDraftBotPart, sendRenderedBotPart, } from "./utils/telegram-text.js";
 import { formatAssistantRunFooter } from "./utils/assistant-run-footer.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
 import { getStoredModel } from "../model/manager.js";
@@ -86,6 +87,7 @@ let heartbeatTimer = null;
 let unsubscribeReadyRestore = null;
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
+const RESPONSE_STREAMING_MODE = config.bot.responseStreamingMode;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
 const SESSION_RETRY_PREFIX = "🔁";
 const SUBAGENT_STREAM_PREFIX = "🧩";
@@ -168,56 +170,105 @@ const toolMessageBatcher = new ToolMessageBatcher({
         }
     },
 });
-const responseStreamer = new ResponseStreamer({
-    throttleMs: RESPONSE_STREAM_THROTTLE_MS,
-    sendPart: async (part, options) => {
-        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
-            throw new Error("Bot context missing for streamed send");
-        }
-        return sendRenderedBotPart({
-            api: botInstance.api,
-            chatId: chatIdInstance,
-            part,
-            options,
-        });
-    },
-    editPart: async (messageId, part, options) => {
-        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
-            throw new Error("Bot context missing for streamed edit");
-        }
-        try {
-            return await editRenderedBotPart({
+let nextDraftId = 1;
+function getNextDraftId() {
+    const id = nextDraftId;
+    nextDraftId += 1;
+    return id;
+}
+const responseStreamer = RESPONSE_STREAMING_MODE === "draft"
+    ? new ResponseStreamer({
+        throttleMs: RESPONSE_STREAM_THROTTLE_MS,
+        sendPart: async (part) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for draft send");
+            }
+            const draftId = getNextDraftId();
+            const result = await sendDraftBotPart({
+                api: botInstance.api,
+                chatId: chatIdInstance,
+                draftId,
+                part,
+            });
+            return { messageId: draftId, deliveredSignature: result.deliveredSignature };
+        },
+        editPart: async (messageId, part) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for draft edit");
+            }
+            return sendDraftBotPart({
+                api: botInstance.api,
+                chatId: chatIdInstance,
+                draftId: messageId,
+                part,
+            });
+        },
+        deleteText: async () => {
+            // Drafts are ephemeral — no need to delete
+        },
+        completePart: async (part, options) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for draft complete");
+            }
+            return completeDraftPart({
                 api: botInstance.api,
                 chatId: chatIdInstance,
-                messageId,
                 part,
                 options,
             });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-            if (errorMessage.includes("message is not modified")) {
-                return {
-                    deliveredSignature: getTelegramRenderedPartSignature(part),
-                };
+        },
+    })
+    : new ResponseStreamer({
+        throttleMs: RESPONSE_STREAM_THROTTLE_MS,
+        sendPart: async (part, options) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for streamed send");
             }
-            throw error;
-        }
-    },
-    deleteText: async (messageId) => {
-        if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
-            throw new Error("Bot context missing for streamed delete");
-        }
-        await botInstance.api.deleteMessage(chatIdInstance, messageId).catch((error) => {
-            const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-            if (errorMessage.includes("message to delete not found") ||
-                errorMessage.includes("message identifier is not specified")) {
-                return;
+            return sendRenderedBotPart({
+                api: botInstance.api,
+                chatId: chatIdInstance,
+                part,
+                options,
+            });
+        },
+        editPart: async (messageId, part, options) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for streamed edit");
             }
-            throw error;
-        });
-    },
-});
+            try {
+                return await editRenderedBotPart({
+                    api: botInstance.api,
+                    chatId: chatIdInstance,
+                    messageId,
+                    part,
+                    options,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+                if (errorMessage.includes("message is not modified")) {
+                    return {
+                        deliveredSignature: getTelegramRenderedPartSignature(part),
+                    };
+                }
+                throw error;
+            }
+        },
+        deleteText: async (messageId) => {
+            if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
+                throw new Error("Bot context missing for streamed delete");
+            }
+            await botInstance.api.deleteMessage(chatIdInstance, messageId).catch((error) => {
+                const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+                if (errorMessage.includes("message to delete not found") ||
+                    errorMessage.includes("message identifier is not specified")) {
+                    return;
+                }
+                throw error;
+            });
+        },
+    });
+setResponseStreamerForReconciliation(responseStreamer);
 const toolCallStreamer = new ToolCallStreamer({
     throttleMs: RESPONSE_STREAM_THROTTLE_MS,
     sendText: async (sessionId, text) => {
@@ -928,6 +979,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);
@@ -964,6 +1016,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);
@@ -971,9 +1025,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 &&
@@ -984,6 +1039,8 @@ export function createBot() {
                 !handledQuestion &&
                 !handledPermission &&
                 !handledAgent &&
+                !handledModelSearch &&
+                !handledModelSearchResults &&
                 !handledModel &&
                 !handledVariant &&
                 !handledCompactConfirm &&
@@ -991,6 +1048,7 @@ export function createBot() {
                 !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands &&
+                !handledMessages &&
                 !handledSkills &&
                 !handledMcps) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
@@ -1183,6 +1241,10 @@ export function createBot() {
         if (handledTask) {
             return;
         }
+        const handledModelSearchText = await handleModelSearchTextInput(ctx);
+        if (handledModelSearchText) {
+            return;
+        }
         const handledRename = await handleRenameTextAnswer(ctx);
         if (handledRename) {
             return;

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

@@ -56,12 +56,14 @@ export class ResponseStreamer {
     sendPart;
     editPart;
     deleteText;
+    completePart;
     states = new Map();
     constructor(options) {
         this.throttleMs = Math.max(0, Math.floor(options.throttleMs));
         this.sendPart = options.sendPart;
         this.editPart = options.editPart;
         this.deleteText = options.deleteText;
+        this.completePart = options.completePart;
     }
     enqueue(sessionId, messageId, payload) {
         const normalizedPayload = normalizePayload(payload);
@@ -105,8 +107,22 @@ export class ResponseStreamer {
         let synced = true;
         if (options?.flushFinal !== false) {
             synced = await this.enqueueTask(state, () => this.flushState(state, "complete"));
-            if (!synced && state.isBroken) {
-                await this.cleanupBrokenStream(state, "final_sync_failed_cleanup");
+        }
+        if (synced && this.completePart && state.latestPayload) {
+            try {
+                const realMessageIds = [];
+                for (const part of state.latestPayload.parts) {
+                    if (!part.text) {
+                        continue;
+                    }
+                    const result = await this.completePart(part, state.latestPayload.sendOptions);
+                    realMessageIds.push(result.messageId);
+                }
+                state.telegramMessageIds = realMessageIds;
+            }
+            catch (error) {
+                logger.error(`[ResponseStreamer] Failed to persist draft message: session=${sessionId}, message=${messageId}`, error);
+                synced = false;
             }
         }
         const messageIds = [...state.telegramMessageIds];
@@ -144,6 +160,14 @@ export class ResponseStreamer {
             logger.debug(`[ResponseStreamer] Cleared all streams: count=${count}, reason=${reason}`);
         }
     }
+    hasActiveStream(sessionId) {
+        for (const state of this.states.values()) {
+            if (state.sessionId === sessionId && !state.cancelled) {
+                return true;
+            }
+        }
+        return false;
+    }
     getOrCreateState(sessionId, messageId) {
         const key = buildStateKey(sessionId, messageId);
         const existing = this.states.get(key);

package/dist/bot/utils/assistant-run-footer.js

@@ -1,9 +1,20 @@
 import { getAgentDisplayName } from "../../agent/types.js";
-function formatElapsedSeconds(elapsedMs) {
-    const safeElapsedMs = Math.max(0, elapsedMs);
-    return `${(safeElapsedMs / 1000).toFixed(1)}s`;
+function formatDuration(elapsedMs) {
+    const safeElapsedMs = Math.max(0, Math.round(elapsedMs));
+    const totalSeconds = Math.floor(safeElapsedMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(" ");
 }
 export function formatAssistantRunFooter({ agent, providerID, modelID, elapsedMs, }) {
     const agentDisplay = getAgentDisplayName(agent);
-    return `${agentDisplay} · 🤖 ${providerID}/${modelID} · 🕒 ${formatElapsedSeconds(elapsedMs)}`;
+    return `${agentDisplay} · 🤖 ${providerID}/${modelID} · 🕒 ${formatDuration(elapsedMs)}`;
 }

package/dist/bot/utils/busy-reconciliation.js

@@ -10,6 +10,10 @@ const RECONCILE_MIN_INTERVAL_MS = 10_000;
 const FOREGROUND_BUSY_RECONCILE_GRACE_MS = 2_000;
 const inFlightDirectories = new Set();
 const lastReconcileAtByDirectory = new Map();
+let responseStreamerInstance = null;
+export function setResponseStreamerForReconciliation(streamer) {
+    responseStreamerInstance = streamer;
+}
 function getReconciliationTargets(directory) {
     const foregroundBusySessions = foregroundSessionState
         .getBusySessions()
@@ -72,6 +76,10 @@ export async function reconcileBusyStateNow(directory, now = Date.now()) {
             logger.debug(`[BusyReconciliation] Skipping fresh foreground busy state: session=${session.sessionId}, directory=${session.directory}, status=${status?.type ?? "not-found"}`);
             continue;
         }
+        if (responseStreamerInstance?.hasActiveStream(session.sessionId)) {
+            logger.debug(`[BusyReconciliation] Skipping clear, responseStreamer still active: session=${session.sessionId}`);
+            continue;
+        }
         logger.info(`[BusyReconciliation] Clearing stale foreground busy state: session=${session.sessionId}, directory=${session.directory}, status=${status?.type ?? "not-found"}`);
         if (attachedSessionForDirectory?.sessionId !== session.sessionId) {
             await markAttachedSessionIdle(session.sessionId);