@markusylisiurunen/tau 0.3.2 → 0.3.4

package/dist/core/{async/telegram.js → telegram/adapter.js}

@@ -4,7 +4,7 @@ import { basename, extname, join } from "node:path";
 import { z } from "zod";
 import { transcribeAudio } from "../utils/speech_to_text.js";
 import { formatZodError } from "../utils/zod.js";
-import { AsyncSessionManagerError, createScopedAsyncSessionManager, } from "./session_manager.js";
+import { createScopedTelegramSessionManager, TelegramSessionManagerError, } from "./session_manager.js";
 const DEFAULT_POLL_INTERVAL_MS = 1000;
 const DEFAULT_REQUEST_TIMEOUT_SECONDS = 30;
 const MAX_COMMAND_PREVIEW_CHARS = 128;
@@ -17,19 +17,24 @@ const DEFAULT_TELEGRAM_DOCUMENT_MIME_TYPE = "application/octet-stream";
 const MESSAGE_QUEUED_REACTION_EMOJI = "👀";
 const MESSAGE_QUEUED_REACTION_DELAY_MS = 1000;
 const TELEGRAM_MAX_MESSAGE_BYTES = 4096;
+const TELEGRAM_MAX_RICH_MESSAGE_BYTES = 32 * 1024;
 const TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO = 0.95;
 const TELEGRAM_SAFE_MESSAGE_BYTES = Math.floor(TELEGRAM_MAX_MESSAGE_BYTES * TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO);
+const TELEGRAM_RICH_MESSAGE_SAFE_BYTES = Math.floor(TELEGRAM_MAX_RICH_MESSAGE_BYTES * TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO);
 const TELEGRAM_MESSAGE_SPLIT_DELAY_MS = 1000;
+const TELEGRAM_DRAFT_MAX_CHARS = 4096;
+const TELEGRAM_DRAFT_THINKING_MARKDOWN = "<tg-thinking>Thinking...</tg-thinking>";
+const TELEGRAM_DRAFT_PREAMBLE_VISIBLE_MS = 10_000;
+const TELEGRAM_DRAFT_REFRESH_MS = 20_000;
+const TELEGRAM_TYPING_REFRESH_MS = 4000;
 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 MAX_TELEGRAM_GROUP_PENDING_MESSAGES = 50;
 const TELEGRAM_ATTACHMENT_TEMP_DIR_PREFIX = "tau-telegram-attachments-";
-const NO_ACTIVE_SESSION_MESSAGE = "no active session. use /new or /sessions";
+const NO_ACTIVE_SESSION_MESSAGE = "no active session. use /new";
 const SUPPORTED_TEXT_ATTACHMENT_EXTENSIONS = new Set([
     ".txt",
     ".md",
@@ -98,11 +103,6 @@ async function sweepStaleTelegramAttachmentTempDirs() {
         return;
     }
 }
-const QUICK_ACTION_ROWS = [
-    ["new", "sessions", "status"],
-    ["interrupt", "close"],
-    ["quiet", "verbose"],
-];
 function splitCommandText(text) {
     return text
         .trim()
@@ -196,15 +196,15 @@ function truncateText(text, maxChars) {
     }
     return `${trimmed.slice(0, maxChars - 1)}…`;
 }
-function splitTelegramMessage(text) {
-    if (Buffer.byteLength(text, "utf8") <= TELEGRAM_SAFE_MESSAGE_BYTES) {
+function splitTelegramTextByBytes(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
         return [text];
     }
     const chunks = [];
     let currentChunk = "";
     for (const character of text) {
         const nextChunk = `${currentChunk}${character}`;
-        if (Buffer.byteLength(nextChunk, "utf8") <= TELEGRAM_SAFE_MESSAGE_BYTES) {
+        if (Buffer.byteLength(nextChunk, "utf8") <= maxBytes) {
             currentChunk = nextChunk;
             continue;
         }
@@ -220,6 +220,12 @@ function splitTelegramMessage(text) {
     }
     return chunks;
 }
+function splitTelegramMessage(text) {
+    return splitTelegramTextByBytes(text, TELEGRAM_SAFE_MESSAGE_BYTES);
+}
+function splitTelegramRichMessage(text) {
+    return splitTelegramTextByBytes(text, TELEGRAM_RICH_MESSAGE_SAFE_BYTES);
+}
 function normalizeSizeBytes(value) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
         return undefined;
@@ -478,6 +484,30 @@ function createTelegramApi(botToken) {
                 ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
             }, z.unknown());
         },
+        async sendRichMessage(chatId, markdown, options) {
+            await callTelegramMethod("sendRichMessage", {
+                chat_id: chatId,
+                rich_message: {
+                    markdown,
+                },
+                ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
+            }, z.unknown());
+        },
+        async sendRichMessageDraft(chatId, draftId, markdown) {
+            await callTelegramMethod("sendRichMessageDraft", {
+                chat_id: chatId,
+                draft_id: draftId,
+                rich_message: {
+                    markdown,
+                },
+            }, TelegramAckResultSchema);
+        },
+        async sendChatAction(chatId, action) {
+            await callTelegramMethod("sendChatAction", {
+                chat_id: chatId,
+                action,
+            }, TelegramAckResultSchema);
+        },
         async downloadFile(fileId) {
             const parsed = await callTelegramMethod("getFile", {
                 file_id: fileId,
@@ -514,7 +544,7 @@ function createTelegramApi(botToken) {
         },
     };
 }
-class AsyncTelegramAdapterImpl {
+class TelegramAdapterImpl {
     projects;
     defaultProjectId;
     systemMessage;
@@ -540,7 +570,9 @@ class AsyncTelegramAdapterImpl {
     activeSessionsByChat = new Map();
     sessionsByChat = new Map();
     chatsBySession = new Map();
-    sessionVerbosityBySession = new Map();
+    chatTypesByChat = new Map();
+    typingIntervalsBySessionChat = new Map();
+    draftStatesBySessionChat = new Map();
     lastCommandBySession = new Map();
     lastAssistantMessageBySession = new Map();
     latestAssistantMessageByRun = new Map();
@@ -612,6 +644,10 @@ class AsyncTelegramAdapterImpl {
         try {
             await this.loopPromise;
             await this.waitForInFlightUpdateTasks();
+            for (const sessionId of Array.from(this.chatsBySession.keys())) {
+                this.stopTypingIndicators(sessionId);
+                this.clearSessionDrafts(sessionId);
+            }
             for (const sessionId of Array.from(this.attachmentTempDirsBySession.keys())) {
                 await this.cleanupSessionAttachmentTempDirs(sessionId);
             }
@@ -627,38 +663,13 @@ class AsyncTelegramAdapterImpl {
     }
     createCommandDefinitions() {
         return [
-            {
-                command: "/help",
-                description: "show supported commands",
-                usage: "/help",
-                handler: async (chatId) => this.handleHelp(chatId),
-            },
             {
                 command: "/new",
                 description: "start a new session",
-                usage: "/new [projectId]",
+                usage: "/new",
                 callbackAction: "new",
                 handler: async (chatId, args, sourceMessageId) => this.handleNew(chatId, args, sourceMessageId),
             },
-            {
-                command: "/projects",
-                description: "list configured projects",
-                usage: "/projects",
-                handler: async (chatId) => this.handleProjects(chatId),
-            },
-            {
-                command: "/use",
-                description: "switch active session",
-                usage: "/use <sessionId|prefix|index>",
-                handler: async (chatId, args) => this.handleUse(chatId, args),
-            },
-            {
-                command: "/sessions",
-                description: "list sessions",
-                usage: "/sessions",
-                callbackAction: "sessions",
-                handler: async (chatId) => this.handleSessions(chatId),
-            },
             {
                 command: "/status",
                 description: "show active session status",
@@ -673,33 +684,9 @@ class AsyncTelegramAdapterImpl {
                 callbackAction: "interrupt",
                 handler: async (chatId) => this.handleInterrupt(chatId),
             },
-            {
-                command: "/close",
-                description: "close session(s)",
-                usage: "/close [<sessionId>|all]",
-                callbackAction: "close",
-                handler: async (chatId, args) => this.handleClose(chatId, args),
-            },
-            {
-                command: "/verbose",
-                description: "stream progress updates",
-                usage: "/verbose",
-                callbackAction: "verbose",
-                handler: async (chatId) => this.handleVerbosityCommand(chatId, "verbose"),
-            },
-            {
-                command: "/quiet",
-                description: "only send final assistant message",
-                usage: "/quiet",
-                callbackAction: "quiet",
-                handler: async (chatId) => this.handleVerbosityCommand(chatId, "quiet"),
-            },
         ];
     }
     async syncCommands() {
-        if (!this.api.setCommands) {
-            return;
-        }
         const commands = this.commandDefinitions.map((definition) => ({
             command: definition.command.slice(1),
             description: definition.description,
@@ -837,6 +824,7 @@ class AsyncTelegramAdapterImpl {
         if (!chat) {
             return;
         }
+        this.chatTypesByChat.set(chat.id, chat.type);
         if (chat.type === "private") {
             await this.handlePrivateMessage(chat.id, message);
             return;
@@ -1277,7 +1265,7 @@ class AsyncTelegramAdapterImpl {
         if (!this.enforceChatOwnership) {
             return this.sessionManager;
         }
-        return createScopedAsyncSessionManager({
+        return createScopedTelegramSessionManager({
             sessionManager: this.sessionManager,
             ownerId: this.ownerIdForChat(chatId),
             allowedProjectIds: this.allowedProjectIds,
@@ -1289,20 +1277,12 @@ class AsyncTelegramAdapterImpl {
         const args = parts.slice(1);
         const handler = this.commandHandlers.get(command);
         if (!handler) {
-            await this.reply(chatId, "unsupported command. use /help");
+            await this.reply(chatId, "unsupported command. supported commands: /new, /status, /interrupt");
             return;
         }
         await handler(chatId, args, sourceMessageId);
     }
     async handleCallback(chatId, callbackData) {
-        if (callbackData.startsWith(CALLBACK_USE_PREFIX)) {
-            const sessionId = callbackData.slice(CALLBACK_USE_PREFIX.length).trim();
-            if (!sessionId) {
-                return false;
-            }
-            await this.handleUse(chatId, [sessionId]);
-            return true;
-        }
         if (!callbackData.startsWith(CALLBACK_ACTION_PREFIX)) {
             return false;
         }
@@ -1314,77 +1294,29 @@ class AsyncTelegramAdapterImpl {
         await handler(chatId, []);
         return true;
     }
-    async handleHelp(chatId) {
-        const lines = [
-            "commands:",
-            ...this.commandDefinitions.map((definition) => definition.usage),
-            "",
-            "tip: use /sessions and tap a session button to switch quickly",
-        ];
-        await this.reply(chatId, lines.join("\n"), {
-            replyMarkup: this.buildQuickActionsKeyboard(),
-        });
-    }
     resolveNewCommand(args) {
-        const projectIds = Object.keys(this.projects);
-        const resolveFallbackProjectId = () => {
-            if (this.defaultProjectId) {
-                if (!this.projects[this.defaultProjectId]) {
-                    return {
-                        error: `telegram.<botId>.defaultProjectId '${this.defaultProjectId}' is not configured`,
-                    };
-                }
-                return { projectId: this.defaultProjectId };
-            }
-            if (projectIds.length === 1) {
-                return { projectId: projectIds[0] };
-            }
-            if (projectIds.length === 0) {
-                return { error: "no async projects configured" };
-            }
-            return {
-                error: "missing project id. usage: /new [projectId]. use /projects to list options",
-            };
-        };
-        if (args.length > 1) {
-            return { error: "usage: /new [projectId]" };
+        if (args.length > 0) {
+            return { error: "usage: /new" };
         }
-        if (args.length === 1) {
-            const projectId = args[0];
-            if (!projectId) {
-                return { error: "usage: /new [projectId]" };
-            }
-            if (!this.projects[projectId]) {
+        const projectIds = Object.keys(this.projects);
+        if (this.defaultProjectId) {
+            if (!this.projects[this.defaultProjectId]) {
                 return {
-                    error: `unknown project '${projectId}'. usage: /new [projectId]. use /projects to list options`,
+                    error: `telegram.<botId>.defaultProjectId '${this.defaultProjectId}' is not configured`,
                 };
             }
-            return { projectId };
+            return { projectId: this.defaultProjectId };
         }
-        const fallback = resolveFallbackProjectId();
-        if (!fallback.projectId) {
-            return {
-                error: fallback.error ?? "unable to resolve project id",
-            };
+        if (projectIds.length === 1) {
+            return { projectId: projectIds[0] };
+        }
+        if (projectIds.length === 0) {
+            return { error: "no telegram projects configured" };
         }
         return {
-            projectId: fallback.projectId,
+            error: "multiple projects configured. set defaultProjectId for this bot before using /new",
         };
     }
-    async handleProjects(chatId) {
-        const entries = Object.entries(this.projects).sort(([left], [right]) => left.localeCompare(right));
-        if (entries.length === 0) {
-            await this.reply(chatId, "no async projects configured");
-            return;
-        }
-        const lines = entries.map(([projectId, project]) => {
-            if (!project.description) {
-                return projectId;
-            }
-            return `${projectId}: ${project.description}`;
-        });
-        await this.reply(chatId, [`projects:`, ...lines].join("\n"));
-    }
     async handleNew(chatId, args, sourceMessageId) {
         const parsed = this.resolveNewCommand(args);
         if ("error" in parsed) {
@@ -1393,134 +1325,27 @@ class AsyncTelegramAdapterImpl {
         }
         try {
             const sessionManager = this.getSessionManagerForChat(chatId);
+            const previousSession = this.getActiveSession(chatId);
+            if (previousSession) {
+                await sessionManager.closeSession(previousSession.id);
+                this.clearClosedSession(previousSession.id);
+            }
             const session = await sessionManager.createSession({
                 projectId: parsed.projectId,
             });
             this.setActiveSession(chatId, session.id);
-            this.sessionVerbosityBySession.set(session.id, "quiet");
             void this.reactToQueuedMessage(chatId, sourceMessageId);
         }
         catch (error) {
             await this.reply(chatId, this.formatManagerError(error));
         }
     }
-    async handleUse(chatId, args) {
-        const selector = args[0]?.trim();
-        if (!selector) {
-            await this.reply(chatId, "usage: /use <sessionId|prefix|index>");
-            return;
-        }
-        const sessionManager = this.getSessionManagerForChat(chatId);
-        const sessions = sessionManager.listSessions();
-        const selectedSession = this.resolveSessionSelector(selector, sessions, sessionManager);
-        if ("error" in selectedSession) {
-            await this.reply(chatId, selectedSession.error);
-            return;
-        }
-        this.setActiveSession(chatId, selectedSession.session.id);
-        await this.reply(chatId, `switched to ${formatTelegramSessionName(selectedSession.session)}.`);
-    }
-    resolveSessionSelector(selector, sessions, sessionManager) {
-        const exactSession = sessionManager.getSession(selector);
-        if (exactSession) {
-            return { session: exactSession };
-        }
-        if (/^\d+$/.test(selector)) {
-            const index = Number.parseInt(selector, 10);
-            if (index <= 0 || index > sessions.length) {
-                return {
-                    error: sessions.length === 0
-                        ? "no sessions"
-                        : `session index '${selector}' is out of range (1-${sessions.length})`,
-                };
-            }
-            const indexedSession = sessions[index - 1];
-            if (!indexedSession) {
-                return { error: "session index lookup failed" };
-            }
-            return { session: indexedSession };
-        }
-        const prefixMatches = sessions.filter((session) => session.id.startsWith(selector));
-        if (prefixMatches.length === 1) {
-            const [prefixMatch] = prefixMatches;
-            if (!prefixMatch) {
-                return { error: "session prefix lookup failed" };
-            }
-            return { session: prefixMatch };
-        }
-        if (prefixMatches.length > 1) {
-            return {
-                error: `session prefix '${selector}' is ambiguous: ${prefixMatches.map((session) => session.id).join(", ")}`,
-            };
-        }
-        return { error: `session '${selector}' not found` };
-    }
-    async handleSessions(chatId) {
-        const sessionManager = this.getSessionManagerForChat(chatId);
-        const sessions = sessionManager.listSessions();
-        const lines = this.formatSessions(chatId, sessions);
-        await this.reply(chatId, lines.join("\n"), {
-            replyMarkup: this.buildSessionsKeyboard(chatId, sessions),
-        });
-    }
-    formatSessions(chatId, sessions) {
-        if (sessions.length === 0) {
-            return ["no sessions"];
-        }
-        const activeSessionId = this.activeSessionsByChat.get(chatId);
-        return [
-            "sessions:",
-            ...sessions.map((session, index) => {
-                const marker = session.id === activeSessionId ? "*" : "-";
-                const preview = this.formatSessionPreview(session.id);
-                return `${index + 1}. ${marker} ${session.id} ${session.projectId} ${session.state}${preview ? ` · ${preview}` : ""}`;
-            }),
-        ];
-    }
-    formatSessionPreview(sessionId) {
-        const previews = [];
-        const lastCommand = this.lastCommandBySession.get(sessionId);
-        if (lastCommand) {
-            previews.push(`$ ${truncateText(lastCommand, MAX_SESSION_PREVIEW_CHARS)}`);
-        }
-        const lastAssistantMessage = this.lastAssistantMessageBySession.get(sessionId);
-        if (lastAssistantMessage) {
-            previews.push(truncateText(lastAssistantMessage, MAX_SESSION_PREVIEW_CHARS));
-        }
-        if (previews.length === 0) {
-            return undefined;
-        }
-        return previews.join(" | ");
-    }
-    buildSessionsKeyboard(chatId, sessions) {
-        const activeSessionId = this.activeSessionsByChat.get(chatId);
-        const inlineKeyboard = sessions.map((session, index) => [
-            {
-                text: `${index + 1}. ${session.id}${session.id === activeSessionId ? " *" : ""}`,
-                callback_data: `${CALLBACK_USE_PREFIX}${session.id}`,
-            },
-        ]);
-        inlineKeyboard.push(...this.buildQuickActionsKeyboard().inline_keyboard);
-        return {
-            inline_keyboard: inlineKeyboard,
-        };
-    }
-    buildQuickActionsKeyboard() {
-        return {
-            inline_keyboard: QUICK_ACTION_ROWS.map((row) => row.map((action) => ({
-                text: `/${action}`,
-                callback_data: `${CALLBACK_ACTION_PREFIX}${action}`,
-            }))),
-        };
-    }
     async handleStatus(chatId) {
         const session = await this.requireActiveSession(chatId);
         if (!session) {
             return;
         }
-        await this.reply(chatId, formatSessionStatus(session), {
-            replyMarkup: this.buildQuickActionsKeyboard(),
-        });
+        await this.reply(chatId, formatSessionStatus(session));
     }
     async handleInterrupt(chatId) {
         const session = await this.requireActiveSession(chatId);
@@ -1540,57 +1365,6 @@ class AsyncTelegramAdapterImpl {
             await this.reply(chatId, this.formatManagerError(error));
         }
     }
-    async handleClose(chatId, args) {
-        if (args.length > 1) {
-            await this.reply(chatId, "usage: /close [<sessionId>|all]");
-            return;
-        }
-        const target = args[0]?.trim();
-        if (target === "all") {
-            try {
-                const sessionManager = this.getSessionManagerForChat(chatId);
-                const closed = await sessionManager.closeInactiveSessions();
-                for (const session of closed) {
-                    this.clearClosedSession(session.id);
-                }
-                if (closed.length === 0) {
-                    await this.reply(chatId, "there are no idle sessions to close.");
-                    return;
-                }
-                const label = closed.length === 1 ? "session" : "sessions";
-                await this.reply(chatId, `closed ${closed.length} idle ${label}.`);
-            }
-            catch (error) {
-                await this.reply(chatId, this.formatManagerError(error));
-            }
-            return;
-        }
-        const sessionId = target ?? this.getActiveSession(chatId)?.id;
-        if (!sessionId) {
-            await this.reply(chatId, NO_ACTIVE_SESSION_MESSAGE);
-            return;
-        }
-        try {
-            const sessionManager = this.getSessionManagerForChat(chatId);
-            const closed = await sessionManager.closeSession(sessionId);
-            this.clearClosedSession(closed.id);
-            await this.reply(chatId, `closed ${formatTelegramSessionName(closed)}.`);
-        }
-        catch (error) {
-            await this.reply(chatId, this.formatManagerError(error));
-        }
-    }
-    async handleVerbosityCommand(chatId, verbosity) {
-        const session = await this.requireActiveSession(chatId);
-        if (!session) {
-            return;
-        }
-        this.sessionVerbosityBySession.set(session.id, verbosity);
-        const message = verbosity === "quiet"
-            ? `${formatTelegramSessionName(session)} is now quiet.`
-            : `${formatTelegramSessionName(session)} will now show progress updates.`;
-        await this.reply(chatId, message);
-    }
     async handleMessage(chatId, text, sourceMessageId) {
         const session = await this.requireActiveOrSingleSession(chatId);
         if (!session) {
@@ -1893,6 +1667,8 @@ class AsyncTelegramAdapterImpl {
         }
     }
     clearClosedSession(sessionId) {
+        this.stopTypingIndicators(sessionId);
+        this.clearSessionDrafts(sessionId);
         for (const [chatId, activeSessionId] of this.activeSessionsByChat) {
             if (activeSessionId === sessionId) {
                 this.activeSessionsByChat.delete(chatId);
@@ -1902,17 +1678,13 @@ class AsyncTelegramAdapterImpl {
         for (const chatId of chatIds) {
             this.unlinkChatFromSession(chatId, sessionId);
         }
-        this.sessionVerbosityBySession.delete(sessionId);
         this.lastCommandBySession.delete(sessionId);
         this.lastAssistantMessageBySession.delete(sessionId);
         this.latestAssistantMessageByRun.delete(sessionId);
         this.clearSessionAttachments(sessionId);
     }
-    getSessionVerbosity(sessionId) {
-        return this.sessionVerbosityBySession.get(sessionId) ?? "quiet";
-    }
-    isVerboseSession(sessionId) {
-        return this.getSessionVerbosity(sessionId) === "verbose";
+    isVerboseSession(_sessionId) {
+        return false;
     }
     onSessionEvent(event) {
         if (event.type === "session-progress") {
@@ -1930,6 +1702,8 @@ class AsyncTelegramAdapterImpl {
         }
         if (event.state === "running") {
             this.latestAssistantMessageByRun.delete(event.sessionId);
+            this.startTypingIndicators(event.sessionId);
+            this.showDraftThinking(event.sessionId);
             if (this.isVerboseSession(event.sessionId)) {
                 this.notifyLifecycle(event.sessionId, event.projectId, "started");
             }
@@ -1937,6 +1711,8 @@ class AsyncTelegramAdapterImpl {
         }
         if (event.state === "failed") {
             this.latestAssistantMessageByRun.delete(event.sessionId);
+            this.stopTypingIndicators(event.sessionId);
+            this.clearSessionDrafts(event.sessionId);
             this.notifyLifecycle(event.sessionId, event.projectId, "failed");
             return;
         }
@@ -1945,6 +1721,8 @@ class AsyncTelegramAdapterImpl {
             return;
         }
         if (event.state === "waiting-input" && event.previousState === "running") {
+            this.stopTypingIndicators(event.sessionId);
+            this.clearSessionDrafts(event.sessionId);
             if (this.isVerboseSession(event.sessionId)) {
                 this.notifyLifecycle(event.sessionId, event.projectId, "finished");
                 return;
@@ -1952,7 +1730,7 @@ class AsyncTelegramAdapterImpl {
             const message = this.latestAssistantMessageByRun.get(event.sessionId);
             this.latestAssistantMessageByRun.delete(event.sessionId);
             if (message) {
-                this.notifySession(event.sessionId, message);
+                this.notifySession(event.sessionId, message, { rich: true });
             }
         }
     }
@@ -1985,6 +1763,7 @@ class AsyncTelegramAdapterImpl {
         }
         this.lastAssistantMessageBySession.set(event.sessionId, event.progress.text);
         this.latestAssistantMessageByRun.set(event.sessionId, event.progress.text);
+        this.showDraftPreamble(event.sessionId, event.progress.text);
         if (!isVerbose) {
             return;
         }
@@ -2002,19 +1781,161 @@ class AsyncTelegramAdapterImpl {
         }
         this.notifySession(sessionId, [formatSessionHeadline(sessionId, stateLabel), `project: ${projectId}`].join("\n"));
     }
-    notifySession(sessionId, text) {
+    notifySession(sessionId, text, options = {}) {
         const chatIds = this.chatsBySession.get(sessionId);
         if (!chatIds || chatIds.size === 0) {
             return;
         }
         for (const chatId of chatIds) {
-            void this.reply(chatId, text);
+            void this.reply(chatId, text, { rich: options.rich }).catch((error) => {
+                this.log("warn", "failed to send telegram notification", {
+                    chatId,
+                    cause: error instanceof Error ? error.message : String(error),
+                });
+            });
         }
     }
-    async reactToQueuedMessage(chatId, messageId) {
-        if (!this.api.setMessageReaction) {
+    startTypingIndicators(sessionId) {
+        const chatIds = this.chatsBySession.get(sessionId);
+        if (!chatIds) {
             return;
         }
+        for (const chatId of chatIds) {
+            const key = this.getSessionChatKey(sessionId, chatId);
+            if (this.typingIntervalsBySessionChat.has(key)) {
+                continue;
+            }
+            const sendTyping = () => {
+                void this.api.sendChatAction(chatId, "typing").catch((error) => {
+                    this.log("warn", "failed to send telegram typing action", {
+                        chatId,
+                        cause: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            };
+            sendTyping();
+            const interval = setInterval(sendTyping, TELEGRAM_TYPING_REFRESH_MS);
+            interval.unref?.();
+            this.typingIntervalsBySessionChat.set(key, interval);
+        }
+    }
+    stopTypingIndicators(sessionId) {
+        const chatIds = this.chatsBySession.get(sessionId);
+        if (!chatIds) {
+            return;
+        }
+        for (const chatId of chatIds) {
+            const key = this.getSessionChatKey(sessionId, chatId);
+            const interval = this.typingIntervalsBySessionChat.get(key);
+            if (interval) {
+                clearInterval(interval);
+                this.typingIntervalsBySessionChat.delete(key);
+            }
+        }
+    }
+    showDraftThinking(sessionId) {
+        const chatIds = this.chatsBySession.get(sessionId);
+        if (!chatIds) {
+            return;
+        }
+        for (const chatId of chatIds) {
+            if (this.chatTypesByChat.get(chatId) !== "private") {
+                continue;
+            }
+            void this.updateMessageDraft(sessionId, chatId, TELEGRAM_DRAFT_THINKING_MARKDOWN);
+        }
+    }
+    showDraftPreamble(sessionId, text) {
+        const chatIds = this.chatsBySession.get(sessionId);
+        if (!chatIds) {
+            return;
+        }
+        for (const chatId of chatIds) {
+            if (this.chatTypesByChat.get(chatId) !== "private") {
+                continue;
+            }
+            const key = this.getSessionChatKey(sessionId, chatId);
+            const state = this.getDraftState(key);
+            if (state.preambleTimeout) {
+                clearTimeout(state.preambleTimeout);
+            }
+            void this.updateMessageDraft(sessionId, chatId, truncateText(text, TELEGRAM_DRAFT_MAX_CHARS));
+            const timeout = setTimeout(() => {
+                const currentState = this.draftStatesBySessionChat.get(key);
+                if (currentState === state) {
+                    void this.updateMessageDraft(sessionId, chatId, TELEGRAM_DRAFT_THINKING_MARKDOWN);
+                }
+            }, TELEGRAM_DRAFT_PREAMBLE_VISIBLE_MS);
+            timeout.unref?.();
+            state.preambleTimeout = timeout;
+        }
+    }
+    async updateMessageDraft(sessionId, chatId, markdown) {
+        const key = this.getSessionChatKey(sessionId, chatId);
+        const state = this.getDraftState(key);
+        state.markdown = markdown;
+        this.startMessageDraftRefresh(sessionId, chatId, state);
+        await this.sendMessageDraft(chatId, state);
+    }
+    startMessageDraftRefresh(sessionId, chatId, state) {
+        if (state.refreshInterval) {
+            return;
+        }
+        const interval = setInterval(() => {
+            const currentState = this.draftStatesBySessionChat.get(this.getSessionChatKey(sessionId, chatId));
+            if (currentState !== state) {
+                clearInterval(interval);
+                return;
+            }
+            void this.sendMessageDraft(chatId, currentState);
+        }, TELEGRAM_DRAFT_REFRESH_MS);
+        interval.unref?.();
+        state.refreshInterval = interval;
+    }
+    async sendMessageDraft(chatId, state) {
+        try {
+            await this.api.sendRichMessageDraft(chatId, state.draftId, state.markdown);
+        }
+        catch (error) {
+            this.log("warn", "failed to update telegram message draft", {
+                chatId,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    clearSessionDrafts(sessionId) {
+        const chatIds = this.chatsBySession.get(sessionId);
+        if (!chatIds) {
+            return;
+        }
+        for (const chatId of chatIds) {
+            const key = this.getSessionChatKey(sessionId, chatId);
+            const state = this.draftStatesBySessionChat.get(key);
+            if (state?.preambleTimeout) {
+                clearTimeout(state.preambleTimeout);
+            }
+            if (state?.refreshInterval) {
+                clearInterval(state.refreshInterval);
+            }
+            this.draftStatesBySessionChat.delete(key);
+        }
+    }
+    getDraftState(key) {
+        const existing = this.draftStatesBySessionChat.get(key);
+        if (existing) {
+            return existing;
+        }
+        const state = { draftId: this.createDraftId(), markdown: TELEGRAM_DRAFT_THINKING_MARKDOWN };
+        this.draftStatesBySessionChat.set(key, state);
+        return state;
+    }
+    createDraftId() {
+        return Math.floor(Math.random() * 2_000_000_000) + 1;
+    }
+    getSessionChatKey(sessionId, chatId) {
+        return `${sessionId}:${chatId}`;
+    }
+    async reactToQueuedMessage(chatId, messageId) {
         if (typeof messageId !== "number" || !Number.isInteger(messageId) || messageId <= 0) {
             return;
         }
@@ -2034,9 +1955,6 @@ class AsyncTelegramAdapterImpl {
         }
     }
     async answerCallbackQuery(callbackQueryId, text) {
-        if (!this.api.answerCallbackQuery) {
-            return;
-        }
         const trimmedCallbackQueryId = callbackQueryId?.trim();
         if (!trimmedCallbackQueryId) {
             return;
@@ -2058,26 +1976,35 @@ class AsyncTelegramAdapterImpl {
         return formatSessionHeadline(sessionId, "message queued");
     }
     formatManagerError(error) {
-        if (error instanceof AsyncSessionManagerError) {
+        if (error instanceof TelegramSessionManagerError) {
             return error.message;
         }
         return error instanceof Error ? error.message : String(error);
     }
     async reply(chatId, text, options) {
-        const chunks = splitTelegramMessage(text);
+        if (options?.rich === true) {
+            await this.replyWithRichMessage(chatId, text, options.replyMarkup);
+            return;
+        }
+        await this.replyWithPlainMessage(chatId, text, options?.replyMarkup);
+    }
+    async replyWithRichMessage(chatId, text, replyMarkup) {
+        const chunks = splitTelegramRichMessage(text);
         for (const [index, chunk] of chunks.entries()) {
-            try {
-                await this.api.sendMessage(chatId, chunk, {
-                    replyMarkup: index === chunks.length - 1 ? options?.replyMarkup : undefined,
-                });
-            }
-            catch (error) {
-                this.log("warn", "failed to send telegram message", {
-                    chatId,
-                    cause: error instanceof Error ? error.message : String(error),
-                });
-                return;
+            await this.api.sendRichMessage(chatId, chunk, {
+                replyMarkup: index === chunks.length - 1 ? replyMarkup : undefined,
+            });
+            if (index < chunks.length - 1) {
+                await this.wait(TELEGRAM_MESSAGE_SPLIT_DELAY_MS);
             }
+        }
+    }
+    async replyWithPlainMessage(chatId, text, replyMarkup) {
+        const chunks = splitTelegramMessage(text);
+        for (const [index, chunk] of chunks.entries()) {
+            await this.api.sendMessage(chatId, chunk, {
+                replyMarkup: index === chunks.length - 1 ? replyMarkup : undefined,
+            });
             if (index < chunks.length - 1) {
                 await this.wait(TELEGRAM_MESSAGE_SPLIT_DELAY_MS);
             }
@@ -2101,14 +2028,14 @@ class AsyncTelegramAdapterImpl {
         });
     }
 }
-export async function startAsyncTelegramAdapter(options) {
+export async function startTelegramAdapter(options) {
     await sweepStaleTelegramAttachmentTempDirs();
     const api = options.api ?? createTelegramApi(options.botToken);
     const botUsername = normalizeTelegramUsername((await api.getMe()).username);
     if (!botUsername) {
         throw new Error("telegram bot username is missing");
     }
-    const adapter = new AsyncTelegramAdapterImpl({
+    const adapter = new TelegramAdapterImpl({
         ...options,
         api,
         botUsername,
@@ -2117,4 +2044,4 @@ export async function startAsyncTelegramAdapter(options) {
         close: () => adapter.close(),
     };
 }
-//# sourceMappingURL=telegram.js.map
+//# sourceMappingURL=adapter.js.map