opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/commands/start.js

@@ -0,0 +1,67 @@
+import { createDmKeyboard, createMainKeyboard } from "../utils/keyboard.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { abortCurrentOperation } from "./abort.js";
+import { clearSession } from "../../session/manager.js";
+import { clearProject } from "../../settings/manager.js";
+import { t } from "../../i18n/index.js";
+import { SCOPE_CONTEXT, getScopeFromContext } from "../scope.js";
+export async function startCommand(ctx) {
+    const scope = getScopeFromContext(ctx);
+    const scopeKey = scope?.key ?? "global";
+    const usePinned = ctx.chat?.type !== "private";
+    const isPrivateChat = ctx.chat?.type === "private";
+    const isTopicScope = scope?.context === SCOPE_CONTEXT.GROUP_TOPIC;
+    if (isPrivateChat) {
+        await abortCurrentOperation(ctx, { notifyUser: false });
+        await ctx.reply(`${t("start.welcome")}\n\n${t("start.welcome_dm")}`, {
+            reply_markup: createDmKeyboard(),
+        });
+        return;
+    }
+    if (ctx.chat) {
+        if (usePinned && !pinnedMessageManager.isInitialized(scopeKey)) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id, scopeKey, scope?.threadId ?? null);
+        }
+        keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+    }
+    await abortCurrentOperation(ctx, { notifyUser: false });
+    if (!isTopicScope) {
+        clearSession(scopeKey);
+        clearProject(scopeKey);
+        keyboardManager.clearContext(scopeKey);
+        if (usePinned) {
+            await pinnedMessageManager.clear(scopeKey);
+            if (!pinnedMessageManager.isInitialized(scopeKey) && ctx.chat) {
+                pinnedMessageManager.initialize(ctx.api, ctx.chat.id, scopeKey, scope?.threadId ?? null);
+            }
+        }
+    }
+    if (usePinned && pinnedMessageManager.getContextLimit(scopeKey) === 0) {
+        await pinnedMessageManager.refreshContextLimit(scopeKey);
+    }
+    // Get current agent, model, and context
+    const currentAgent = getStoredAgent(scopeKey);
+    const currentModel = getStoredModel(scopeKey);
+    const variantName = formatVariantForButton(currentModel.variant || "default");
+    const contextInfo = keyboardManager.getContextInfo(scopeKey) ??
+        (usePinned ? pinnedMessageManager.getContextInfo(scopeKey) : null) ??
+        (usePinned && pinnedMessageManager.getContextLimit(scopeKey) > 0
+            ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(scopeKey) }
+            : null);
+    keyboardManager.updateAgent(currentAgent, scopeKey);
+    keyboardManager.updateModel(currentModel, scopeKey);
+    if (contextInfo) {
+        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit, scopeKey);
+    }
+    const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName, scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+        ? {
+            contextFirst: true,
+            contextLabel: t("keyboard.general_defaults"),
+        }
+        : undefined);
+    await ctx.reply(t("start.welcome"), { reply_markup: keyboard });
+}

package/dist/bot/commands/status.js

@@ -0,0 +1,138 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { fetchCurrentAgent } from "../../agent/manager.js";
+import { getAgentDisplayName } from "../../agent/types.js";
+import { fetchCurrentModel } from "../../model/manager.js";
+import { formatModelForDisplay } from "../../model/types.js";
+import { processManager } from "../../process/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { sendMessageWithMarkdownFallback } from "../utils/send-with-markdown-fallback.js";
+import { createDmKeyboard } from "../utils/keyboard.js";
+import { getScopeFromContext, getScopeKeyFromContext, getThreadSendOptions } from "../scope.js";
+export async function statusCommand(ctx) {
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        const scope = getScopeFromContext(ctx);
+        const usePinned = ctx.chat?.type !== "private";
+        const isPrivateChat = ctx.chat?.type === "private";
+        const { data, error } = await opencodeClient.global.health();
+        if (error || !data) {
+            throw error || new Error("No data received from server");
+        }
+        if (isPrivateChat) {
+            const [projectsResult, sessionsResult] = await Promise.all([
+                opencodeClient.project.list(),
+                opencodeClient.session.list({ limit: 200 }),
+            ]);
+            const projectCount = projectsResult.data?.length ?? 0;
+            const sessionCount = sessionsResult.data?.length ?? 0;
+            const healthLabel = data.healthy ? t("status.health.healthy") : t("status.health.unhealthy");
+            let dmMessage = `📊 ${t("status.dm.title")}\n\n`;
+            dmMessage += `${t("status.line.health", { health: healthLabel })}\n`;
+            if (data.version) {
+                dmMessage += `${t("status.line.version", { version: data.version })}\n`;
+            }
+            if (processManager.isRunning()) {
+                const uptime = processManager.getUptime();
+                const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
+                dmMessage += `${t("status.line.managed_yes")}\n`;
+                dmMessage += `${t("status.line.pid", { pid: processManager.getPID() ?? "-" })}\n`;
+                dmMessage += `${t("status.line.uptime_sec", { seconds: uptimeStr })}\n`;
+            }
+            else {
+                dmMessage += `${t("status.line.managed_no")}\n`;
+            }
+            dmMessage += `\n${t("status.global_overview")}\n`;
+            dmMessage += `${t("status.global_projects", { count: projectCount })}\n`;
+            dmMessage += `${t("status.global_sessions", { count: sessionCount })}\n\n`;
+            dmMessage += t("status.dm.hint");
+            await ctx.reply(dmMessage, { reply_markup: createDmKeyboard() });
+            return;
+        }
+        let message = `${t("status.header_running")}\n\n`;
+        const healthLabel = data.healthy ? t("status.health.healthy") : t("status.health.unhealthy");
+        message += `${t("status.line.health", { health: healthLabel })}\n`;
+        if (data.version) {
+            message += `${t("status.line.version", { version: data.version })}\n`;
+        }
+        // Add process management information
+        if (processManager.isRunning()) {
+            const uptime = processManager.getUptime();
+            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
+            message += `${t("status.line.managed_yes")}\n`;
+            message += `${t("status.line.pid", { pid: processManager.getPID() ?? "-" })}\n`;
+            message += `${t("status.line.uptime_sec", { seconds: uptimeStr })}\n`;
+        }
+        else {
+            message += `${t("status.line.managed_no")}\n`;
+        }
+        // Add agent mode information
+        const currentAgent = await fetchCurrentAgent(scopeKey);
+        const agentDisplay = currentAgent
+            ? getAgentDisplayName(currentAgent)
+            : t("status.agent_not_set");
+        message += `${t("status.line.mode", { mode: agentDisplay })}\n`;
+        // Add model information
+        const currentModel = fetchCurrentModel(scopeKey);
+        const modelDisplay = formatModelForDisplay(currentModel.providerID, currentModel.modelID);
+        message += `${t("status.line.model", { model: modelDisplay })}\n`;
+        const currentProject = getCurrentProject(scopeKey);
+        if (currentProject) {
+            const projectName = currentProject.name || currentProject.worktree;
+            message += `\n${t("status.project_selected", { project: projectName })}\n`;
+        }
+        else {
+            message += `\n${t("status.project_not_selected")}\n`;
+            message += t("status.project_hint");
+        }
+        const currentSession = getCurrentSession(scopeKey);
+        if (currentSession) {
+            message += `\n${t("status.session_selected", { title: currentSession.title })}\n`;
+        }
+        else {
+            message += `\n${t("status.session_not_selected")}\n`;
+            message += t("status.session_hint");
+        }
+        if (ctx.chat) {
+            if (usePinned && !pinnedMessageManager.isInitialized(scopeKey)) {
+                pinnedMessageManager.initialize(ctx.api, ctx.chat.id, scopeKey, scope?.threadId ?? null);
+            }
+            if (usePinned && pinnedMessageManager.getContextLimit(scopeKey) === 0) {
+                await pinnedMessageManager.refreshContextLimit(scopeKey);
+            }
+            keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+        }
+        const contextInfo = (usePinned ? pinnedMessageManager.getContextInfo(scopeKey) : null) ??
+            keyboardManager.getContextInfo(scopeKey);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit, scopeKey);
+        }
+        else if (usePinned && pinnedMessageManager.getContextLimit(scopeKey) > 0) {
+            keyboardManager.updateContext(0, pinnedMessageManager.getContextLimit(scopeKey), scopeKey);
+        }
+        const keyboard = keyboardManager.getKeyboard(scopeKey);
+        if (ctx.chat) {
+            await sendMessageWithMarkdownFallback({
+                api: ctx.api,
+                chatId: ctx.chat.id,
+                text: message,
+                options: {
+                    reply_markup: keyboard,
+                    ...getThreadSendOptions(scope?.threadId ?? null),
+                },
+                parseMode: "Markdown",
+            });
+        }
+        else {
+            await ctx.reply(message, { reply_markup: keyboard });
+        }
+    }
+    catch (error) {
+        logger.error("[Bot] Error checking server status:", error);
+        await ctx.reply(t("status.server_unavailable"));
+    }
+}

package/dist/bot/constants.js

@@ -0,0 +1,49 @@
+export const CHAT_TYPE = {
+    PRIVATE: "private",
+    GROUP: "group",
+    SUPERGROUP: "supergroup",
+    CHANNEL: "channel",
+};
+export const TELEGRAM_CHAT_FIELD = {
+    IS_FORUM: "is_forum",
+    USERNAME: "username",
+};
+export const GENERAL_TOPIC = {
+    NAME: "🧭 Session Control",
+};
+export const TELEGRAM_ERROR_MARKER = {
+    NOT_ENOUGH_RIGHTS_CREATE_TOPIC: "not enough rights to create a topic",
+};
+export const TELEGRAM_URL = {
+    BASE: "https://t.me",
+    PRIVATE_SUPERGROUP_PATH: "/c",
+};
+export const TELEGRAM_CHAT_ID_PREFIX = {
+    PRIVATE_SUPERGROUP: "100",
+};
+export const BOT_I18N_KEY = {
+    GROUP_GENERAL_PROMPTS_DISABLED: "group.general.prompts_disabled",
+    GROUP_GENERAL_COMMANDS_ONLY: "group.general.commands_only",
+    TOPIC_UNBOUND: "topic.unbound",
+    TOPIC_CREATE_FROM_GENERAL: "topic.create_from_general",
+    CLEANUP_TOPIC_USE_GENERAL: "cleanup.topic_use_general",
+    CLEANUP_REQUIRES_FORUM_GENERAL: "cleanup.requires_forum_general",
+    CLEANUP_NO_TOPICS: "cleanup.no_topics",
+    CLEANUP_RESULT: "cleanup.result",
+    NEW_TOPIC_ONLY_IN_GENERAL: "new.topic_only_in_general",
+    NEW_REQUIRES_FORUM_GENERAL: "new.requires_forum_general",
+    NEW_TOPIC_CREATE_ERROR: "new.topic_create_error",
+    NEW_TOPIC_CREATE_NO_RIGHTS: "new.topic_create_no_rights",
+    NEW_TOPIC_CREATED: "new.topic_created",
+    NEW_GENERAL_CREATED: "new.general_created",
+    NEW_GENERAL_OPEN_LINK: "new.general_open_link",
+    SESSIONS_TOPIC_LOCKED: "sessions.topic_locked",
+    SESSIONS_GENERAL_OVERVIEW: "sessions.general_overview",
+    SESSIONS_GENERAL_ITEM: "sessions.general_item",
+    SESSIONS_GENERAL_EMPTY: "sessions.general_empty",
+    SESSIONS_BOUND_TOPIC_LINK: "sessions.bound_topic_link",
+    SESSIONS_CREATED_TOPIC_LINK: "sessions.created_topic_link",
+    PROJECTS_LOCKED_TOPIC_SCOPE: "projects.locked.topic_scope",
+    PROJECTS_LOCKED_GROUP_PROJECT: "projects.locked.group_project",
+    PROJECTS_LOCKED_CALLBACK: "projects.locked.callback",
+};

package/dist/bot/handlers/agent.js

@@ -0,0 +1,127 @@
+import { InlineKeyboard } from "grammy";
+import { selectAgent, getAvailableAgents, fetchCurrentAgent } from "../../agent/manager.js";
+import { getAgentDisplayName, getAgentEmoji } from "../../agent/types.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { logger } from "../../utils/logger.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { t } from "../../i18n/index.js";
+import { SCOPE_CONTEXT, getScopeFromKey, getScopeKeyFromContext } from "../scope.js";
+/**
+ * Handle agent selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleAgentSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("agent:")) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "agent");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug(`[AgentHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+        }
+        if (pinnedMessageManager.getContextLimit(scopeKey) === 0) {
+            await pinnedMessageManager.refreshContextLimit(scopeKey);
+        }
+        const agentName = callbackQuery.data.replace("agent:", "");
+        // Select agent and persist
+        selectAgent(agentName, scopeKey);
+        // Update keyboard manager state
+        keyboardManager.updateAgent(agentName, scopeKey);
+        // Update Reply Keyboard with new agent, current model, and context
+        const currentModel = getStoredModel(scopeKey);
+        const contextInfo = pinnedMessageManager.getContextInfo(scopeKey) ??
+            (pinnedMessageManager.getContextLimit(scopeKey) > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(scopeKey) }
+                : keyboardManager.getContextInfo(scopeKey));
+        keyboardManager.updateModel(currentModel, scopeKey);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit, scopeKey);
+        }
+        const state = keyboardManager.getState(scopeKey);
+        const variantName = state?.variantName ?? formatVariantForButton(currentModel.variant || "default");
+        const scope = getScopeFromKey(scopeKey);
+        const keyboard = createMainKeyboard(agentName, currentModel, contextInfo ?? undefined, variantName, scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+            ? {
+                contextFirst: true,
+                contextLabel: t("keyboard.general_defaults"),
+            }
+            : undefined);
+        const displayName = getAgentDisplayName(agentName);
+        clearActiveInlineMenu("agent_selected", scopeKey);
+        // Send confirmation message with updated keyboard
+        await ctx.answerCallbackQuery({ text: t("agent.changed_callback", { name: displayName }) });
+        await ctx.reply(t("agent.changed_message", { name: displayName }), {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("agent_select_error", getScopeKeyFromContext(ctx));
+        logger.error("[AgentHandler] Error handling agent select:", err);
+        await ctx.answerCallbackQuery({ text: t("agent.change_error_callback") }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with available agents
+ * @param currentAgent Current agent name for highlighting
+ * @returns InlineKeyboard with agent selection buttons
+ */
+export async function buildAgentSelectionMenu(scopeKey, currentAgent) {
+    const keyboard = new InlineKeyboard();
+    const agents = await getAvailableAgents(scopeKey);
+    if (agents.length === 0) {
+        logger.warn("[AgentHandler] No available agents found");
+        return keyboard;
+    }
+    // Add button for each agent
+    agents.forEach((agent) => {
+        const emoji = getAgentEmoji(agent.name);
+        const isActive = agent.name === currentAgent;
+        const label = isActive
+            ? `✅ ${emoji} ${agent.name.toUpperCase()}`
+            : `${emoji} ${agent.name.charAt(0).toUpperCase() + agent.name.slice(1)}`;
+        keyboard.text(label, `agent:${agent.name}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show agent selection menu
+ * @param ctx grammY context
+ */
+export async function showAgentSelectionMenu(ctx) {
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        const currentAgent = await fetchCurrentAgent(scopeKey);
+        const keyboard = await buildAgentSelectionMenu(scopeKey, currentAgent);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("agent.menu.empty"));
+            return;
+        }
+        const text = currentAgent
+            ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
+            : t("agent.menu.select");
+        await replyWithInlineMenu(ctx, {
+            menuKind: "agent",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[AgentHandler] Error showing agent menu:", err);
+        await ctx.reply(t("agent.menu.error"));
+    }
+}

package/dist/bot/handlers/context.js

@@ -0,0 +1,125 @@
+import { InlineKeyboard } from "grammy";
+import { getCurrentSession } from "../../session/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getStoredModel } from "../../model/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { GENERAL_TOPIC_THREAD_ID, SCOPE_CONTEXT, getChatActionThreadOptions, getScopeFromContext, getScopeKeyFromContext, getThreadSendOptions, } from "../scope.js";
+import { TELEGRAM_CHAT_ACTION } from "../telegram-constants.js";
+import { CHAT_TYPE, TELEGRAM_CHAT_FIELD } from "../constants.js";
+function isGeneralForumScope(ctx) {
+    const scope = getScopeFromContext(ctx);
+    const isForumEnabled = ctx.chat?.type === CHAT_TYPE.SUPERGROUP &&
+        Reflect.get(ctx.chat, TELEGRAM_CHAT_FIELD.IS_FORUM) === true;
+    return Boolean(isForumEnabled &&
+        scope?.context === SCOPE_CONTEXT.GROUP_GENERAL &&
+        (scope.threadId === null || scope.threadId === GENERAL_TOPIC_THREAD_ID));
+}
+/**
+ * Build inline keyboard with compact confirmation menu
+ * @returns InlineKeyboard with confirmation button
+ */
+export function buildCompactConfirmationMenu() {
+    const keyboard = new InlineKeyboard();
+    keyboard.text(t("context.button.confirm"), "compact:confirm");
+    return keyboard;
+}
+/**
+ * Handle context button press (text message from Reply Keyboard)
+ * Shows inline menu with compact confirmation
+ * @param ctx grammY context
+ */
+export async function handleContextButtonPress(ctx) {
+    logger.debug("[ContextHandler] Context button pressed");
+    const scope = getScopeFromContext(ctx);
+    const scopeKey = getScopeKeyFromContext(ctx);
+    if (isGeneralForumScope(ctx)) {
+        await ctx.reply(t("context.general_not_available"), getThreadSendOptions(scope?.threadId ?? null));
+        return;
+    }
+    const session = getCurrentSession(scopeKey);
+    if (!session) {
+        await ctx.reply(t("context.no_active_session"), getThreadSendOptions(scope?.threadId ?? null));
+        return;
+    }
+    const keyboard = buildCompactConfirmationMenu();
+    await replyWithInlineMenu(ctx, {
+        menuKind: "context",
+        text: t("context.confirm_text", { title: session.title }),
+        keyboard,
+    });
+}
+/**
+ * Handle compact confirmation callback
+ * Calls OpenCode API to compact the session
+ * @param ctx grammY context
+ */
+export async function handleCompactConfirm(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || callbackQuery.data !== "compact:confirm") {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "context");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug("[ContextHandler] Compact confirmed");
+    try {
+        const scope = getScopeFromContext(ctx);
+        const scopeKey = getScopeKeyFromContext(ctx);
+        if (isGeneralForumScope(ctx)) {
+            clearActiveInlineMenu("context_general_scope", scopeKey);
+            await ctx.answerCallbackQuery({ text: t("context.general_not_available_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        const session = getCurrentSession(scopeKey);
+        if (!session) {
+            clearActiveInlineMenu("context_session_missing", scopeKey);
+            await ctx.answerCallbackQuery({ text: t("context.callback_session_not_found") });
+            await ctx.reply(t("context.no_active_session"), getThreadSendOptions(scope?.threadId ?? null));
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        // Answer callback query and delete menu immediately
+        await ctx.answerCallbackQuery({ text: t("context.callback_compacting") });
+        clearActiveInlineMenu("context_compact_confirmed", scopeKey);
+        await ctx.deleteMessage().catch(() => { });
+        // Send progress message
+        const progressMessage = await ctx.reply(t("context.progress"), getThreadSendOptions(scope?.threadId ?? null));
+        // Show typing indicator
+        await ctx.api.sendChatAction(ctx.chat.id, TELEGRAM_CHAT_ACTION.TYPING, getChatActionThreadOptions(scope?.threadId ?? null));
+        const storedModel = getStoredModel(scopeKey);
+        logger.debug(`[ContextHandler] Calling summarize with sessionID=${session.id}, directory=${session.directory}, model=${storedModel.providerID}/${storedModel.modelID}`);
+        // Call summarize API (AI compaction)
+        const { error } = await opencodeClient.session.summarize({
+            sessionID: session.id,
+            directory: session.directory,
+            providerID: storedModel.providerID,
+            modelID: storedModel.modelID,
+        });
+        if (error) {
+            logger.error("[ContextHandler] Compact failed:", error);
+            // Update progress message to show error
+            await ctx.api
+                .editMessageText(ctx.chat.id, progressMessage.message_id, t("context.error"))
+                .catch(() => { });
+            return true;
+        }
+        logger.info(`[ContextHandler] Session compacted: ${session.id}`);
+        // Update progress message to show success
+        await ctx.api
+            .editMessageText(ctx.chat.id, progressMessage.message_id, t("context.success"))
+            .catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("context_compact_error", getScopeKeyFromContext(ctx));
+        logger.error("[ContextHandler] Compact exception:", err);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        await ctx.reply(t("context.error"), getThreadSendOptions(getScopeFromContext(ctx)?.threadId ?? null));
+        await ctx.deleteMessage().catch(() => { });
+        return false;
+    }
+}

package/dist/bot/handlers/document.js

@@ -0,0 +1,65 @@
+import { config } from "../../config.js";
+import { processUserPrompt } from "./prompt.js";
+import { downloadTelegramFile, toDataUri, isTextMimeType, isFileSizeAllowed, } from "../utils/file-download.js";
+import { getModelCapabilities, supportsInput } from "../../model/capabilities.js";
+import { getStoredModel } from "../../model/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+export async function handleDocumentMessage(ctx, deps) {
+    const downloadFile = deps.downloadFile ?? downloadTelegramFile;
+    const getCapabilities = deps.getModelCapabilities ?? getModelCapabilities;
+    const getStored = deps.getStoredModel ?? getStoredModel;
+    const processPrompt = deps.processPrompt ?? processUserPrompt;
+    const doc = ctx.message?.document;
+    if (!doc) {
+        return;
+    }
+    const caption = ctx.message.caption || "";
+    const mimeType = doc.mime_type || "";
+    const filename = doc.file_name || "document";
+    try {
+        if (isTextMimeType(mimeType)) {
+            if (!isFileSizeAllowed(doc.file_size, config.files.maxFileSizeKb)) {
+                logger.warn(`[Document] Text file too large: ${filename} (${doc.file_size} bytes > ${config.files.maxFileSizeKb}KB)`);
+                await ctx.reply(t("bot.text_file_too_large", { maxSizeKb: String(config.files.maxFileSizeKb) }));
+                return;
+            }
+            await ctx.reply(t("bot.file_downloading"));
+            const downloadedFile = await downloadFile(ctx.api, doc.file_id);
+            const textContent = downloadedFile.buffer.toString("utf-8");
+            const promptWithFile = `--- Content of ${filename} ---\n${textContent}\n--- End of file ---\n\n${caption}`;
+            logger.info(`[Document] Sending text file (${downloadedFile.buffer.length} bytes, ${filename}) as prompt`);
+            await processPrompt(ctx, promptWithFile, deps);
+            return;
+        }
+        if (mimeType === "application/pdf") {
+            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);
+                }
+                return;
+            }
+            await ctx.reply(t("bot.file_downloading"));
+            const downloadedFile = await downloadFile(ctx.api, doc.file_id);
+            const dataUri = toDataUri(downloadedFile.buffer, mimeType);
+            const filePart = {
+                type: "file",
+                mime: mimeType,
+                filename: filename,
+                url: dataUri,
+            };
+            logger.info(`[Document] Sending PDF (${downloadedFile.buffer.length} bytes, ${filename}) with prompt`);
+            await processPrompt(ctx, caption, deps, [filePart]);
+            return;
+        }
+        logger.debug(`[Document] Unsupported document MIME type: ${mimeType}, ignoring`);
+    }
+    catch (err) {
+        logger.error("[Document] Error handling document message:", err);
+        await ctx.reply(t("bot.file_download_error"));
+    }
+}