@markusylisiurunen/tau 0.2.53 → 0.2.55

package/dist/core/async/telegram.js

@@ -1,3 +1,6 @@
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, extname, join } from "node:path";
 import { Api } from "grammy";
 import { transcribeMistralAudio } from "../utils/mistral_transcription.js";
 import { isRecord } from "../utils/type_guards.js";
@@ -9,12 +12,86 @@ const DEFAULT_TELEGRAM_VOICE_MIME_TYPE = "audio/ogg";
 const DEFAULT_TELEGRAM_VOICE_FILE_NAME = "voice.ogg";
 const DEFAULT_TELEGRAM_AUDIO_MIME_TYPE = "audio/mpeg";
 const DEFAULT_TELEGRAM_AUDIO_FILE_NAME = "audio.mp3";
+const DEFAULT_TELEGRAM_PHOTO_MIME_TYPE = "image/jpeg";
+const DEFAULT_TELEGRAM_DOCUMENT_MIME_TYPE = "application/octet-stream";
 const MESSAGE_QUEUED_REACTION_EMOJI = "👀";
 const MESSAGE_QUEUED_REACTION_DELAY_MS = 1000;
 const ABORTED = Symbol("aborted");
 const CALLBACK_ACTION_PREFIX = "tau:action:";
 const CALLBACK_USE_PREFIX = "tau:use:";
 const MAX_SESSION_PREVIEW_CHARS = 64;
+const MAX_TELEGRAM_ATTACHMENTS_PER_TURN = 10;
+const MAX_TELEGRAM_ATTACHMENT_FILE_BYTES = 20 * 1024 * 1024;
+const MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES = 50 * 1024 * 1024;
+const TELEGRAM_ATTACHMENT_TEMP_DIR_PREFIX = "tau-telegram-attachments-";
+const SUPPORTED_TEXT_ATTACHMENT_EXTENSIONS = new Set([
+    ".txt",
+    ".md",
+    ".json",
+    ".csv",
+    ".yaml",
+    ".yml",
+]);
+const SUPPORTED_IMAGE_ATTACHMENT_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".webp", ".gif"]);
+const SUPPORTED_TEXT_ATTACHMENT_MIME_TYPES = new Set([
+    "text/plain",
+    "text/markdown",
+    "application/json",
+    "text/csv",
+    "application/csv",
+    "text/yaml",
+    "application/yaml",
+    "application/x-yaml",
+    "text/x-yaml",
+]);
+const MIME_EXTENSION_BY_TYPE = {
+    "application/pdf": ".pdf",
+    "application/json": ".json",
+    "text/markdown": ".md",
+    "text/csv": ".csv",
+    "application/csv": ".csv",
+    "text/plain": ".txt",
+    "text/yaml": ".yaml",
+    "application/yaml": ".yaml",
+    "application/x-yaml": ".yaml",
+    "text/x-yaml": ".yaml",
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+};
+const MIME_TYPE_BY_EXTENSION = {
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".csv": "text/csv",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+async function sweepStaleTelegramAttachmentTempDirs() {
+    const systemTmpDir = tmpdir();
+    try {
+        const entries = await readdir(systemTmpDir, { withFileTypes: true, encoding: "utf8" });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith(TELEGRAM_ATTACHMENT_TEMP_DIR_PREFIX)) {
+                continue;
+            }
+            try {
+                await rm(join(systemTmpDir, entry.name), { recursive: true, force: true });
+            }
+            catch { }
+        }
+    }
+    catch {
+        return;
+    }
+}
 const TELEGRAM_COMMANDS = [
     { command: "help", description: "show supported commands" },
     { command: "new", description: "start a new session" },
@@ -23,7 +100,6 @@ const TELEGRAM_COMMANDS = [
     { command: "sessions", description: "list sessions" },
     { command: "status", description: "show active session status" },
     { command: "interrupt", description: "interrupt active run" },
-    { command: "cancel", description: "cancel active session" },
     { command: "close", description: "close session(s)" },
     { command: "verbose", description: "stream progress updates" },
     { command: "quiet", description: "only send final assistant message" },
@@ -52,6 +128,112 @@ function truncateText(text, maxChars) {
     }
     return `${trimmed.slice(0, maxChars - 1)}…`;
 }
+function normalizeSizeBytes(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const rounded = Math.floor(value);
+    if (rounded <= 0) {
+        return undefined;
+    }
+    return rounded;
+}
+function selectLargestPhotoVariant(variants) {
+    if (!variants || variants.length === 0) {
+        return undefined;
+    }
+    let selected;
+    let selectedScore = -1;
+    for (const variant of variants) {
+        const fileId = variant.file_id?.trim();
+        if (!fileId) {
+            continue;
+        }
+        const fileSize = normalizeSizeBytes(variant.file_size);
+        const width = normalizeSizeBytes(variant.width) ?? 0;
+        const height = normalizeSizeBytes(variant.height) ?? 0;
+        const resolutionScore = width * height;
+        const sizeScore = fileSize ?? 0;
+        const score = Math.max(sizeScore, resolutionScore);
+        if (!selected || score >= selectedScore) {
+            selected = variant;
+            selectedScore = score;
+        }
+    }
+    const selectedFileId = selected?.file_id?.trim();
+    if (!selectedFileId) {
+        return undefined;
+    }
+    return {
+        fileId: selectedFileId,
+        sizeBytes: normalizeSizeBytes(selected?.file_size),
+    };
+}
+function inferExtensionFromMimeType(mimeType) {
+    const trimmed = mimeType.trim().toLowerCase();
+    if (!trimmed) {
+        return undefined;
+    }
+    return MIME_EXTENSION_BY_TYPE[trimmed];
+}
+function sanitizeAttachmentFileName(fileName, fallback) {
+    const trimmed = basename(fileName.trim());
+    const normalized = trimmed
+        .replace(/\s+/g, "-")
+        .replace(/[^a-zA-Z0-9._-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^[-.]+/, "")
+        .replace(/[-.]+$/, "");
+    if (!normalized) {
+        return fallback;
+    }
+    return normalized;
+}
+function inferMimeTypeFromFileName(fileName) {
+    const extension = extname(fileName.trim()).toLowerCase();
+    if (!extension) {
+        return undefined;
+    }
+    return MIME_TYPE_BY_EXTENSION[extension];
+}
+function isSupportedDocumentAttachment(mimeType, fileName) {
+    const normalizedMimeType = mimeType.trim().toLowerCase();
+    if (normalizedMimeType.startsWith("image/")) {
+        return true;
+    }
+    if (normalizedMimeType === "application/pdf") {
+        return true;
+    }
+    if (SUPPORTED_TEXT_ATTACHMENT_MIME_TYPES.has(normalizedMimeType)) {
+        return true;
+    }
+    const extension = extname(fileName.trim()).toLowerCase();
+    if (SUPPORTED_TEXT_ATTACHMENT_EXTENSIONS.has(extension)) {
+        return true;
+    }
+    if (extension === ".pdf") {
+        return true;
+    }
+    return SUPPORTED_IMAGE_ATTACHMENT_EXTENSIONS.has(extension);
+}
+function describeAttachmentLimitBytes(sizeBytes) {
+    const megabytes = sizeBytes / (1024 * 1024);
+    if (Number.isInteger(megabytes)) {
+        return `${megabytes} MB`;
+    }
+    return `${megabytes.toFixed(1)} MB`;
+}
+function describeAttachment(fileName, mimeType) {
+    const trimmedFileName = fileName.trim();
+    const trimmedMimeType = mimeType.trim();
+    if (trimmedFileName) {
+        return `'${trimmedFileName}'`;
+    }
+    if (trimmedMimeType) {
+        return `'${trimmedMimeType}'`;
+    }
+    return "attachment";
+}
 function describeSession(session, details = {}) {
     return [
         formatSessionHeadline(session.id, "status"),
@@ -136,6 +318,9 @@ class AsyncTelegramAdapterImpl {
     lastCommandBySession = new Map();
     lastAssistantMessageBySession = new Map();
     latestAssistantMessageByRun = new Map();
+    pendingAttachmentsBySession = new Map();
+    pendingAttachmentTempDirBySession = new Map();
+    attachmentTempDirsBySession = new Map();
     unsubscribeSessionEvents;
     loopPromise;
     nextUpdateOffset = 0;
@@ -176,6 +361,11 @@ class AsyncTelegramAdapterImpl {
         this.closed = true;
         this.abortController.abort();
         this.unsubscribeSessionEvents();
+        for (const sessionId of Array.from(this.attachmentTempDirsBySession.keys())) {
+            await this.cleanupSessionAttachmentTempDirs(sessionId);
+        }
+        this.pendingAttachmentsBySession.clear();
+        this.pendingAttachmentTempDirBySession.clear();
         try {
             await this.loopPromise;
         }
@@ -275,8 +465,12 @@ class AsyncTelegramAdapterImpl {
                 return;
             }
             const text = typeof message.text === "string" ? message.text.trim() : "";
+            const isCommand = text.startsWith("/");
+            if (!isCommand) {
+                await this.queueMessageAttachments(chatId, message);
+            }
             if (text) {
-                if (text.startsWith("/")) {
+                if (isCommand) {
                     await this.handleCommand(chatId, text);
                     return;
                 }
@@ -335,6 +529,222 @@ class AsyncTelegramAdapterImpl {
             fileName: message.audio?.file_name?.trim() || DEFAULT_TELEGRAM_AUDIO_FILE_NAME,
         };
     }
+    async queueMessageAttachments(chatId, message) {
+        const caption = typeof message.caption === "string" ? message.caption.trim() : "";
+        const attachmentCaption = caption || undefined;
+        const parsedAttachments = [];
+        const photo = selectLargestPhotoVariant(message.photo);
+        if (photo) {
+            const extension = inferExtensionFromMimeType(DEFAULT_TELEGRAM_PHOTO_MIME_TYPE) ?? ".jpg";
+            const fileName = sanitizeAttachmentFileName(`photo${extension}`, `photo${extension}`);
+            parsedAttachments.push({
+                fileId: photo.fileId,
+                fileName,
+                mimeType: DEFAULT_TELEGRAM_PHOTO_MIME_TYPE,
+                sizeBytes: photo.sizeBytes,
+                caption: attachmentCaption,
+            });
+        }
+        const documentFileId = message.document?.file_id?.trim();
+        if (documentFileId) {
+            const rawMimeType = message.document?.mime_type?.trim().toLowerCase();
+            const mimeTypeForExtension = rawMimeType && rawMimeType !== DEFAULT_TELEGRAM_DOCUMENT_MIME_TYPE
+                ? rawMimeType
+                : undefined;
+            const inferredExtension = inferExtensionFromMimeType(mimeTypeForExtension ?? "") ?? "";
+            const fallbackFileName = `attachment${inferredExtension}`;
+            const rawFileName = message.document?.file_name?.trim() || fallbackFileName;
+            let fileName = sanitizeAttachmentFileName(rawFileName, fallbackFileName || "attachment");
+            if (!extname(fileName) && inferredExtension) {
+                fileName = `${fileName}${inferredExtension}`;
+            }
+            const mimeType = mimeTypeForExtension ??
+                inferMimeTypeFromFileName(fileName) ??
+                rawMimeType ??
+                DEFAULT_TELEGRAM_DOCUMENT_MIME_TYPE;
+            if (!isSupportedDocumentAttachment(mimeType, fileName)) {
+                await this.reply(chatId, `skipped attachment ${describeAttachment(fileName, mimeType)}: unsupported file type`);
+            }
+            else {
+                parsedAttachments.push({
+                    fileId: documentFileId,
+                    fileName,
+                    mimeType,
+                    sizeBytes: normalizeSizeBytes(message.document?.file_size),
+                    caption: attachmentCaption,
+                });
+            }
+        }
+        if (parsedAttachments.length === 0) {
+            return;
+        }
+        const session = this.getActiveOrSingleSession(chatId);
+        if (!session) {
+            await this.reply(chatId, "no active session. use /new or /sessions");
+            return;
+        }
+        const pending = this.pendingAttachmentsBySession.get(session.id) ?? [];
+        let totalSizeBytes = pending.reduce((total, attachment) => {
+            return total + (attachment.materialized?.sizeBytes ?? attachment.declaredSizeBytes ?? 0);
+        }, 0);
+        for (const attachment of parsedAttachments) {
+            const attachmentLabel = describeAttachment(attachment.fileName, attachment.mimeType);
+            if (pending.length >= MAX_TELEGRAM_ATTACHMENTS_PER_TURN) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds attachment limit (${MAX_TELEGRAM_ATTACHMENTS_PER_TURN} files per turn)`);
+                continue;
+            }
+            if (typeof attachment.sizeBytes === "number" &&
+                attachment.sizeBytes > MAX_TELEGRAM_ATTACHMENT_FILE_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-file limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_FILE_BYTES)})`);
+                continue;
+            }
+            if (typeof attachment.sizeBytes === "number" &&
+                totalSizeBytes + attachment.sizeBytes > MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-turn total limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES)})`);
+                continue;
+            }
+            let bytes;
+            try {
+                bytes = await this.api.downloadFile(attachment.fileId);
+            }
+            catch (error) {
+                await this.reply(chatId, `failed to download attachment ${attachmentLabel}: ${this.formatManagerError(error)}`);
+                continue;
+            }
+            const sizeBytes = bytes.byteLength;
+            if (sizeBytes > MAX_TELEGRAM_ATTACHMENT_FILE_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-file limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_FILE_BYTES)})`);
+                continue;
+            }
+            if (totalSizeBytes + sizeBytes > MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-turn total limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES)})`);
+                continue;
+            }
+            const tempDirPath = await this.getOrCreatePendingAttachmentTempDir(session.id);
+            const indexedFileName = `${String(pending.length + 1).padStart(2, "0")}-${attachment.fileName}`;
+            const filePath = join(tempDirPath, indexedFileName);
+            try {
+                await writeFile(filePath, bytes);
+            }
+            catch (error) {
+                await this.reply(chatId, `failed to materialize attachment ${attachmentLabel}: ${this.formatManagerError(error)}`);
+                continue;
+            }
+            pending.push({
+                fileId: attachment.fileId,
+                fileName: attachment.fileName,
+                mimeType: attachment.mimeType,
+                declaredSizeBytes: attachment.sizeBytes,
+                caption: attachment.caption,
+                materialized: {
+                    path: filePath,
+                    sizeBytes,
+                },
+            });
+            totalSizeBytes += sizeBytes;
+        }
+        if (pending.length > 0) {
+            this.pendingAttachmentsBySession.set(session.id, pending);
+        }
+    }
+    async buildMessageTextWithAttachments(sessionId, text, chatId) {
+        const attachments = await this.materializePendingAttachments(sessionId, chatId);
+        if (attachments.length === 0) {
+            return text;
+        }
+        return [this.formatAttachmentBlock(attachments), text].join("\n\n");
+    }
+    formatAttachmentBlock(attachments) {
+        const lines = ["attachments:"];
+        for (const attachment of attachments) {
+            lines.push(`- path: ${attachment.path}`);
+            lines.push(`  mime: ${attachment.mimeType}`);
+            lines.push(`  size_bytes: ${attachment.sizeBytes}`);
+            if (attachment.caption) {
+                lines.push(`  caption: ${JSON.stringify(attachment.caption)}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    async materializePendingAttachments(sessionId, chatId) {
+        const pending = this.pendingAttachmentsBySession.get(sessionId);
+        if (!pending || pending.length === 0) {
+            return [];
+        }
+        let totalSizeBytes = 0;
+        const nextPending = [];
+        const readyAttachments = [];
+        for (const attachment of pending) {
+            const attachmentLabel = describeAttachment(attachment.fileName, attachment.mimeType);
+            const materialized = attachment.materialized;
+            if (!materialized) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: local temp file is missing`);
+                continue;
+            }
+            if (materialized.sizeBytes > MAX_TELEGRAM_ATTACHMENT_FILE_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-file limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_FILE_BYTES)})`);
+                continue;
+            }
+            if (totalSizeBytes + materialized.sizeBytes > MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES) {
+                await this.reply(chatId, `skipped attachment ${attachmentLabel}: exceeds per-turn total limit (${describeAttachmentLimitBytes(MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES)})`);
+                continue;
+            }
+            totalSizeBytes += materialized.sizeBytes;
+            nextPending.push(attachment);
+            readyAttachments.push({
+                path: materialized.path,
+                mimeType: attachment.mimeType,
+                sizeBytes: materialized.sizeBytes,
+                caption: attachment.caption,
+            });
+        }
+        if (nextPending.length === 0) {
+            this.pendingAttachmentsBySession.delete(sessionId);
+        }
+        else {
+            this.pendingAttachmentsBySession.set(sessionId, nextPending);
+        }
+        return readyAttachments;
+    }
+    async getOrCreatePendingAttachmentTempDir(sessionId) {
+        const existingPath = this.pendingAttachmentTempDirBySession.get(sessionId);
+        if (existingPath) {
+            return existingPath;
+        }
+        const directoryPath = await mkdtemp(join(tmpdir(), TELEGRAM_ATTACHMENT_TEMP_DIR_PREFIX));
+        this.pendingAttachmentTempDirBySession.set(sessionId, directoryPath);
+        const directories = this.attachmentTempDirsBySession.get(sessionId) ?? new Set();
+        directories.add(directoryPath);
+        this.attachmentTempDirsBySession.set(sessionId, directories);
+        return directoryPath;
+    }
+    resetPendingAttachmentQueue(sessionId) {
+        this.pendingAttachmentsBySession.delete(sessionId);
+        this.pendingAttachmentTempDirBySession.delete(sessionId);
+    }
+    clearSessionAttachments(sessionId) {
+        this.resetPendingAttachmentQueue(sessionId);
+        void this.cleanupSessionAttachmentTempDirs(sessionId);
+    }
+    async cleanupSessionAttachmentTempDirs(sessionId) {
+        const directories = this.attachmentTempDirsBySession.get(sessionId);
+        if (!directories || directories.size === 0) {
+            return;
+        }
+        this.attachmentTempDirsBySession.delete(sessionId);
+        for (const directoryPath of directories) {
+            try {
+                await rm(directoryPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                this.log("warn", "failed to clean up telegram attachment temp directory", {
+                    sessionId,
+                    directoryPath,
+                    cause: this.formatManagerError(error),
+                });
+            }
+        }
+    }
     isChatAllowed(chatId) {
         if (!this.allowedChatIds) {
             return true;
@@ -382,10 +792,6 @@ class AsyncTelegramAdapterImpl {
             await this.handleInterrupt(chatId);
             return;
         }
-        if (command === "/cancel") {
-            await this.handleCancel(chatId);
-            return;
-        }
         if (command === "/close") {
             await this.handleClose(chatId, args);
             return;
@@ -429,8 +835,8 @@ class AsyncTelegramAdapterImpl {
             await this.handleInterrupt(chatId);
             return true;
         }
-        if (action === "cancel") {
-            await this.handleCancel(chatId);
+        if (action === "close") {
+            await this.handleClose(chatId, []);
             return true;
         }
         if (action === "quiet") {
@@ -453,7 +859,6 @@ class AsyncTelegramAdapterImpl {
             "/use <sessionId|prefix|index>",
             "/status",
             "/interrupt",
-            "/cancel",
             "/close [<sessionId>|all]",
             "/verbose",
             "/quiet",
@@ -651,7 +1056,7 @@ class AsyncTelegramAdapterImpl {
                 ],
                 [
                     { text: "/interrupt", callback_data: `${CALLBACK_ACTION_PREFIX}interrupt` },
-                    { text: "/cancel", callback_data: `${CALLBACK_ACTION_PREFIX}cancel` },
+                    { text: "/close", callback_data: `${CALLBACK_ACTION_PREFIX}close` },
                 ],
                 [
                     { text: "/quiet", callback_data: `${CALLBACK_ACTION_PREFIX}quiet` },
@@ -692,20 +1097,6 @@ class AsyncTelegramAdapterImpl {
             await this.reply(chatId, this.formatManagerError(error));
         }
     }
-    async handleCancel(chatId) {
-        const session = this.getActiveSession(chatId);
-        if (!session) {
-            await this.reply(chatId, "no active session. use /new or /sessions");
-            return;
-        }
-        try {
-            const canceled = await this.sessionManager.cancelSession(session.id);
-            await this.reply(chatId, formatSessionHeadline(canceled.id, "canceled"));
-        }
-        catch (error) {
-            await this.reply(chatId, this.formatManagerError(error));
-        }
-    }
     async handleClose(chatId, args) {
         if (args.length > 1) {
             await this.reply(chatId, "usage: /close [<sessionId>|all]");
@@ -760,7 +1151,9 @@ class AsyncTelegramAdapterImpl {
             return;
         }
         try {
-            await this.sessionManager.sendMessage(session.id, text, this.systemMessage ? { additionalSystemMessage: this.systemMessage } : undefined);
+            const textWithAttachments = await this.buildMessageTextWithAttachments(session.id, text, chatId);
+            await this.sessionManager.sendMessage(session.id, textWithAttachments, this.systemMessage ? { additionalSystemMessage: this.systemMessage } : undefined);
+            this.resetPendingAttachmentQueue(session.id);
             await this.reactToQueuedMessage(chatId, sourceMessageId);
             if (this.isVerboseSession(session.id)) {
                 await this.reply(chatId, this.formatMessageQueued(session.id));
@@ -771,7 +1164,7 @@ class AsyncTelegramAdapterImpl {
         }
     }
     async handleAudioMessage(chatId, message, sourceMessageId) {
-        const session = this.getActiveSession(chatId);
+        const session = this.getActiveOrSingleSession(chatId);
         if (!session) {
             await this.reply(chatId, "no active session. use /new or /sessions");
             return;
@@ -800,7 +1193,9 @@ class AsyncTelegramAdapterImpl {
             return;
         }
         try {
-            await this.sessionManager.sendMessage(session.id, transcript, this.systemMessage ? { additionalSystemMessage: this.systemMessage } : undefined);
+            const textWithAttachments = await this.buildMessageTextWithAttachments(session.id, transcript, chatId);
+            await this.sessionManager.sendMessage(session.id, textWithAttachments, this.systemMessage ? { additionalSystemMessage: this.systemMessage } : undefined);
+            this.resetPendingAttachmentQueue(session.id);
             await this.reactToQueuedMessage(chatId, sourceMessageId);
             if (this.isVerboseSession(session.id)) {
                 await this.reply(chatId, this.formatMessageQueued(session.id));
@@ -818,6 +1213,7 @@ class AsyncTelegramAdapterImpl {
         const session = this.sessionManager.getSession(sessionId);
         if (!session) {
             this.clearActiveSession(chatId);
+            this.clearSessionAttachments(sessionId);
             return undefined;
         }
         return session;
@@ -889,6 +1285,7 @@ class AsyncTelegramAdapterImpl {
         this.lastCommandBySession.delete(sessionId);
         this.lastAssistantMessageBySession.delete(sessionId);
         this.latestAssistantMessageByRun.delete(sessionId);
+        this.clearSessionAttachments(sessionId);
     }
     getSessionVerbosity(sessionId) {
         return this.sessionVerbosityBySession.get(sessionId) ?? "quiet";
@@ -916,11 +1313,6 @@ class AsyncTelegramAdapterImpl {
             this.notifyLifecycle(event.sessionId, event.projectId, "failed");
             return;
         }
-        if (event.state === "canceled") {
-            this.latestAssistantMessageByRun.delete(event.sessionId);
-            this.notifyLifecycle(event.sessionId, event.projectId, "canceled");
-            return;
-        }
         if (event.state === "waiting-input" && event.previousState === "preparing-workspace") {
             this.notifySession(event.sessionId, this.formatSessionReady(event.sessionId, event.projectId));
             return;
@@ -976,7 +1368,6 @@ class AsyncTelegramAdapterImpl {
             started: "run started",
             finished: "run finished",
             failed: "run failed",
-            canceled: "run canceled",
         }[state];
         this.notifySession(sessionId, [formatSessionHeadline(sessionId, stateLabel), `project: ${projectId}`].join("\n"));
     }
@@ -1074,6 +1465,7 @@ class AsyncTelegramAdapterImpl {
     }
 }
 export async function startAsyncTelegramAdapter(options) {
+    await sweepStaleTelegramAttachmentTempDirs();
     const adapter = new AsyncTelegramAdapterImpl(options);
     return {
         close: () => adapter.close(),