@markusylisiurunen/tau 0.3.69 → 0.3.70

package/dist/core/telegram/adapter.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, extname, join } from "node:path";
@@ -543,7 +544,7 @@ const TelegramCallbackQuerySchema = telegramPartialObject({
     id: z.string(),
     from: TelegramUserSchema,
     data: z.string(),
-    message: telegramPartialObject({ chat: TelegramChatSchema }),
+    message: telegramPartialObject({ message_id: z.number(), chat: TelegramChatSchema }),
 });
 const TelegramUpdateSchema = telegramPartialObject({
     update_id: z.number(),
@@ -721,6 +722,14 @@ function createTelegramApi(botToken) {
                 ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
             }, z.unknown(), options.signal);
         },
+        async editMessage(chatId, messageId, text, options) {
+            await callTelegramMethod("editMessageText", {
+                chat_id: chatId,
+                message_id: messageId,
+                text,
+                reply_markup: options.replyMarkup ?? { inline_keyboard: [] },
+            }, z.unknown(), options.signal);
+        },
         async sendRichMessage(chatId, markdown, options) {
             await callTelegramMethod("sendRichMessage", {
                 chat_id: chatId,
@@ -806,6 +815,7 @@ class TelegramAdapterImpl {
     commandHandlers;
     callbackActionHandlers;
     abortController = new AbortController();
+    promptPickers = new Map();
     activeSessionsByChat = new Map();
     sessionsByChat = new Map();
     chatsBySession = new Map();
@@ -929,6 +939,11 @@ class TelegramAdapterImpl {
                 callbackAction: "status",
                 handler: async (chatId) => this.handleStatus(chatId),
             },
+            {
+                command: "/prompt",
+                description: "add a saved prompt without starting a turn",
+                handler: async (chatId, args) => this.handlePrompt(chatId, args),
+            },
             {
                 command: "/compact",
                 description: "compact session context",
@@ -1203,7 +1218,7 @@ class TelegramAdapterImpl {
             await this.answerCallbackQuery(callbackQuery.id);
             return;
         }
-        const callbackHandled = await this.handleCallback(chat.id, callbackData);
+        const callbackHandled = await this.handleCallback(chat.id, callbackData, callbackQuery.message?.message_id);
         await this.answerCallbackQuery(callbackQuery.id, callbackHandled ? "done" : undefined);
     }
     parseAudioMessage(message) {
@@ -1583,7 +1598,11 @@ class TelegramAdapterImpl {
         }
         await handler(chatId, args, sourceMessageId);
     }
-    async handleCallback(chatId, callbackData) {
+    async handleCallback(chatId, callbackData, messageId) {
+        if (callbackData.startsWith("prompt:")) {
+            await this.handlePromptCallback(chatId, callbackData, messageId);
+            return true;
+        }
         if (!callbackData.startsWith(CALLBACK_ACTION_PREFIX)) {
             return false;
         }
@@ -1650,6 +1669,101 @@ class TelegramAdapterImpl {
             await this.reply(chatId, `failed to save voice response preference: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async handlePrompt(chatId, args) {
+        if (args.length > 0) {
+            await this.reply(chatId, "use /prompt to choose a saved prompt.");
+            return;
+        }
+        const session = await this.requireActiveSession(chatId);
+        if (!session)
+            return;
+        try {
+            const snapshot = await this.getSessionManagerForChat(chatId).getSessionSnapshot(session.id);
+            if (!snapshot) {
+                await this.reply(chatId, "the session is still preparing.");
+                return;
+            }
+            const prompts = snapshot.catalog.prompts;
+            if (prompts.length === 0) {
+                await this.reply(chatId, "this session has no saved prompts.");
+                return;
+            }
+            this.promptPickers.set(chatId, { token: randomUUID(), sessionId: session.id, prompts });
+            await this.showPromptPage(chatId, 0);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+        }
+    }
+    async showPromptPage(chatId, page, messageId) {
+        const picker = this.promptPickers.get(chatId);
+        if (!picker)
+            return;
+        const start = page * 20;
+        const keyboard = picker.prompts.slice(start, start + 20).map((prompt, index) => [
+            {
+                text: prompt.label ?? prompt.id,
+                callback_data: `prompt:${picker.token}:select:${start + index}`,
+            },
+        ]);
+        const navigation = [];
+        if (page > 0)
+            navigation.push({
+                text: "previous",
+                callback_data: `prompt:${picker.token}:page:${page - 1}`,
+            });
+        if (start + 20 < picker.prompts.length)
+            navigation.push({ text: "next", callback_data: `prompt:${picker.token}:page:${page + 1}` });
+        if (navigation.length > 0)
+            keyboard.push(navigation);
+        const text = "choose a saved prompt to add to the conversation without starting a turn. selection is available only while Tau is idle.";
+        const replyMarkup = { inline_keyboard: keyboard };
+        if (messageId !== undefined) {
+            await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, text, { replyMarkup, signal }));
+        }
+        else {
+            await this.reply(chatId, text, { replyMarkup });
+        }
+    }
+    async handlePromptCallback(chatId, data, messageId) {
+        const match = /^prompt:([^:]+):(select|page):(0|[1-9][0-9]*)$/.exec(data);
+        const picker = this.promptPickers.get(chatId);
+        if (!match ||
+            !picker ||
+            picker.token !== match[1] ||
+            this.getActiveSession(chatId)?.id !== picker.sessionId ||
+            messageId === undefined) {
+            await this.reply(chatId, "this prompt picker has expired. use /prompt to open a new one.");
+            return;
+        }
+        const index = Number(match[3]);
+        if (match[2] === "page") {
+            if (index * 20 < picker.prompts.length)
+                await this.showPromptPage(chatId, index, messageId);
+            return;
+        }
+        const prompt = picker.prompts[index];
+        if (!prompt)
+            return;
+        let text;
+        try {
+            text = await this.getSessionManagerForChat(chatId).recordPrompt(picker.sessionId, prompt.id);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+            return;
+        }
+        this.promptPickers.delete(chatId);
+        const chunks = splitTelegramMessage(`added this prompt to the conversation. send a message when you’re ready for Tau to respond.\n\n${text}`);
+        for (const [index, chunk] of chunks.entries()) {
+            if (index === 0) {
+                await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, chunk, { signal }));
+            }
+            else {
+                await this.reply(chatId, chunk);
+            }
+        }
+    }
     async handleSetReasoning(chatId, reasoning, args) {
         if (args.length > 0) {
             await this.reply(chatId, `usage: /effort_${reasoning}`);