@grinev/opencode-telegram-bot 0.20.5 → 0.20.6

package/README.md

@@ -37,7 +37,7 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 - **Skills Catalog** — browse OpenCode skills from an inline menu and run them immediately or with arguments in the next message
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, and optionally enable spoken replies with `/tts`
-- **File attachments** — send images, PDF documents, and any text-based files to OpenCode (code, logs, configs etc.)
+- **File attachments** — send images, PDF documents, and text-based files to OpenCode, including multiple files in one Telegram album
 - **Scheduled tasks** — schedule prompts to run later or on a recurring interval; see [Scheduled Tasks](#scheduled-tasks)
 - **Context control** — compact context when it gets too large, right from the chat
 - **Input flow control** — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions

package/dist/bot/handlers/document.js

@@ -32,6 +32,30 @@ export async function handleDocumentMessage(ctx, deps) {
             await processPrompt(ctx, promptWithFile, deps);
             return;
         }
+        if (mimeType.startsWith("image/")) {
+            const storedModel = getStored();
+            const capabilities = await getCapabilities(storedModel.providerID, storedModel.modelID);
+            if (!supportsInput(capabilities, "image")) {
+                logger.warn(`[Document] Model ${storedModel.providerID}/${storedModel.modelID} doesn't support image input`);
+                await ctx.reply(t("bot.photo_model_no_image"));
+                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 image (${downloadedFile.buffer.length} bytes, ${filename}, ${mimeType}) with prompt`);
+            await processPrompt(ctx, caption, deps, [filePart]);
+            return;
+        }
         if (mimeType === "application/pdf") {
             const storedModel = getStored();
             const capabilities = await getCapabilities(storedModel.providerID, storedModel.modelID);
@@ -56,7 +80,8 @@ export async function handleDocumentMessage(ctx, deps) {
             await processPrompt(ctx, caption, deps, [filePart]);
             return;
         }
-        logger.debug(`[Document] Unsupported document MIME type: ${mimeType}, ignoring`);
+        logger.warn(`[Document] Unsupported document MIME type: ${mimeType}, filename=${filename}`);
+        await ctx.reply(t("bot.file_type_unsupported"));
     }
     catch (err) {
         logger.error("[Document] Error handling document message:", err);

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/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

@@ -57,6 +57,7 @@ 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 { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
@@ -593,14 +594,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) => {
@@ -1103,6 +1106,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}`);

package/dist/i18n/de.js

@@ -64,8 +64,12 @@ export const de = {
     "bot.photo_download_error": "🔴 Foto konnte nicht heruntergeladen werden",
     "bot.photo_no_caption": "💡 Tipp: Füge eine Bildunterschrift hinzu, um zu beschreiben, was du mit diesem Foto tun möchtest.",
     "bot.file_downloading": "⏳ Lade Datei herunter...",
+    "bot.files_downloading": "⏳ Lade Dateien herunter...",
     "bot.file_too_large": "⚠️ Datei ist zu groß (max. {maxSizeMb}MB)",
     "bot.file_download_error": "🔴 Datei konnte nicht heruntergeladen werden",
+    "bot.file_type_unsupported": "⚠️ Dieser Dateityp wird nicht unterstützt. Sende ein Bild, PDF oder eine Text-/Code-Datei.",
+    "bot.media_group_not_processed": "⚠️ Eine oder mehrere Dateien in diesem Album können nicht verarbeitet werden. Es wurde nichts an OpenCode gesendet.",
+    "bot.media_group_download_error": "🔴 Eine der Dateien konnte nicht heruntergeladen werden. Es wurde nichts an OpenCode gesendet.",
     "bot.model_no_pdf": "⚠️ Das aktuelle Modell unterstützt keine PDF-Eingabe. Sende nur Text.",
     "bot.text_file_too_large": "⚠️ Textdatei ist zu groß (max. {maxSizeKb}KB)",
     "status.header_running": "🟢 OpenCode-Server läuft",

package/dist/i18n/en.js

@@ -64,8 +64,12 @@ export const en = {
     "bot.photo_download_error": "🔴 Failed to download photo",
     "bot.photo_no_caption": "💡 Tip: Add a caption to describe what you want to do with this photo.",
     "bot.file_downloading": "⏳ Downloading file...",
+    "bot.files_downloading": "⏳ Downloading files...",
     "bot.file_too_large": "⚠️ File is too large (max {maxSizeMb}MB)",
     "bot.file_download_error": "🔴 Failed to download file",
+    "bot.file_type_unsupported": "⚠️ This file type is not supported. Send an image, PDF, or text/code file.",
+    "bot.media_group_not_processed": "⚠️ One or more files in this album cannot be processed. Nothing was sent to OpenCode.",
+    "bot.media_group_download_error": "🔴 Failed to download one of the files. Nothing was sent to OpenCode.",
     "bot.model_no_pdf": "⚠️ Current model doesn't support PDF input. Sending text only.",
     "bot.text_file_too_large": "⚠️ Text file is too large (max {maxSizeKb}KB)",
     "status.header_running": "🟢 OpenCode Server is running",

package/dist/i18n/es.js

@@ -64,8 +64,12 @@ export const es = {
     "bot.photo_download_error": "🔴 No se pudo descargar la foto",
     "bot.photo_no_caption": "💡 Consejo: agrega un pie de foto para describir que quieres hacer con esta foto.",
     "bot.file_downloading": "⏳ Descargando archivo...",
+    "bot.files_downloading": "⏳ Descargando archivos...",
     "bot.file_too_large": "⚠️ El archivo es demasiado grande (max {maxSizeMb}MB)",
     "bot.file_download_error": "🔴 No se pudo descargar el archivo",
+    "bot.file_type_unsupported": "⚠️ Este tipo de archivo no es compatible. Envía una imagen, PDF o archivo de texto/código.",
+    "bot.media_group_not_processed": "⚠️ Uno o más archivos de este álbum no se pueden procesar. No se envió nada a OpenCode.",
+    "bot.media_group_download_error": "🔴 No se pudo descargar uno de los archivos. No se envió nada a OpenCode.",
     "bot.model_no_pdf": "⚠️ El modelo actual no admite entrada PDF. Enviaré solo texto.",
     "bot.text_file_too_large": "⚠️ El archivo de texto es demasiado grande (max {maxSizeKb}KB)",
     "status.header_running": "🟢 OpenCode Server está en ejecución",

package/dist/i18n/fr.js

@@ -64,8 +64,12 @@ export const fr = {
     "bot.photo_download_error": "🔴 Impossible de télécharger la photo",
     "bot.photo_no_caption": "💡 Conseil : ajoutez une légende pour décrire ce que vous voulez faire avec cette photo.",
     "bot.file_downloading": "⏳ Téléchargement du fichier...",
+    "bot.files_downloading": "⏳ Téléchargement des fichiers...",
     "bot.file_too_large": "⚠️ Le fichier est trop volumineux (max {maxSizeMb}MB)",
     "bot.file_download_error": "🔴 Impossible de télécharger le fichier",
+    "bot.file_type_unsupported": "⚠️ Ce type de fichier n'est pas pris en charge. Envoyez une image, un PDF ou un fichier texte/code.",
+    "bot.media_group_not_processed": "⚠️ Un ou plusieurs fichiers de cet album ne peuvent pas être traités. Rien n'a été envoyé à OpenCode.",
+    "bot.media_group_download_error": "🔴 Impossible de télécharger l'un des fichiers. Rien n'a été envoyé à OpenCode.",
     "bot.model_no_pdf": "⚠️ Le modèle actuel ne prend pas en charge les PDF. Envoi du texte uniquement.",
     "bot.text_file_too_large": "⚠️ Le fichier texte est trop volumineux (max {maxSizeKb}KB)",
     "status.header_running": "🟢 Le serveur OpenCode est en cours d'exécution",

package/dist/i18n/ru.js

@@ -64,8 +64,12 @@ export const ru = {
     "bot.photo_download_error": "🔴 Не удалось скачать фото",
     "bot.photo_no_caption": "💡 Совет: Добавьте подпись, чтобы описать, что делать с этим фото.",
     "bot.file_downloading": "⏳ Скачиваю файл...",
+    "bot.files_downloading": "⏳ Скачиваю файлы...",
     "bot.file_too_large": "⚠️ Файл слишком большой (макс. {maxSizeMb}МБ)",
     "bot.file_download_error": "🔴 Не удалось скачать файл",
+    "bot.file_type_unsupported": "⚠️ Этот тип файла не поддерживается. Отправьте изображение, PDF или текстовый/кодовый файл.",
+    "bot.media_group_not_processed": "⚠️ Один или несколько файлов в альбоме нельзя обработать. В OpenCode ничего не отправлено.",
+    "bot.media_group_download_error": "🔴 Не удалось скачать один из файлов. В OpenCode ничего не отправлено.",
     "bot.model_no_pdf": "⚠️ Текущая модель не поддерживает PDF. Отправляю только текст.",
     "bot.text_file_too_large": "⚠️ Текстовый файл слишком большой (макс. {maxSizeKb}КБ)",
     "status.header_running": "🟢 OpenCode Server запущен",

package/dist/i18n/zh.js

@@ -64,8 +64,12 @@ export const zh = {
     "bot.photo_download_error": "🔴 下载照片失败",
     "bot.photo_no_caption": "💡 提示：添加说明文字以描述你希望对这张照片做什么。",
     "bot.file_downloading": "⏳ 正在下载文件...",
+    "bot.files_downloading": "⏳ 正在下载文件...",
     "bot.file_too_large": "⚠️ 文件过大（最大 {maxSizeMb}MB）",
     "bot.file_download_error": "🔴 下载文件失败",
+    "bot.file_type_unsupported": "⚠️ 不支持此文件类型。请发送图片、PDF 或文本/代码文件。",
+    "bot.media_group_not_processed": "⚠️ 此相册中有一个或多个文件无法处理。未向 OpenCode 发送任何内容。",
+    "bot.media_group_download_error": "🔴 无法下载其中一个文件。未向 OpenCode 发送任何内容。",
     "bot.model_no_pdf": "⚠️ 当前模型不支持PDF输入。将仅发送文本。",
     "bot.text_file_too_large": "⚠️ 文本文件过大（最大 {maxSizeKb}KB）",
     "status.header_running": "🟢 OpenCode 服务器正在运行",

package/dist/summary/aggregator.js

@@ -270,6 +270,12 @@ class SummaryAggregator {
     isTrackedChildSession(sessionId) {
         return this.trackedSessionParents.has(sessionId) && sessionId !== this.currentSessionId;
     }
+    /**
+     * Public check: is this session a tracked subagent (child) of the current root session?
+     */
+    isSubagentSession(sessionId) {
+        return this.isTrackedChildSession(sessionId);
+    }
     getQueue(map, parentSessionId) {
         const existing = map.get(parentSessionId);
         if (existing) {
@@ -1215,11 +1221,13 @@ class SummaryAggregator {
     }
     handlePermissionAsked(event) {
         const request = event.properties;
-        if (request.sessionID !== this.currentSessionId) {
+        const isCurrent = request.sessionID === this.currentSessionId;
+        const isTrackedChild = this.isTrackedChildSession(request.sessionID);
+        if (!isCurrent && !isTrackedChild) {
             logger.debug(`[Aggregator] Ignoring permission.asked for different session: ${request.sessionID} (current: ${this.currentSessionId})`);
             return;
         }
-        logger.info(`[Aggregator] Permission asked: requestID=${request.id}, type=${request.permission}, patterns=${request.patterns.length}`);
+        logger.info(`[Aggregator] Permission asked: requestID=${request.id}, type=${request.permission}, patterns=${request.patterns.length}, subagent=${isTrackedChild}`);
         if (this.onPermissionCallback) {
             const callback = this.onPermissionCallback;
             setImmediate(async () => {

package/package.json

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