dexto 1.3.0 → 1.5.0

package/dist/telegram/bot.js

@@ -1,251 +0,0 @@
-#!/usr/bin/env node
-import dotenv from 'dotenv';
-import { Bot, InlineKeyboard } from 'grammy';
-import https from 'https';
-import { logger } from '@dexto/core';
-// Load environment variables (including TELEGRAM_BOT_TOKEN)
-dotenv.config();
-const token = process.env.TELEGRAM_BOT_TOKEN;
-// Insert concurrency cap and debounce cache for inline queries
-const MAX_CONCURRENT_INLINE_QUERIES = process.env.TELEGRAM_INLINE_QUERY_CONCURRENCY
-    ? Number(process.env.TELEGRAM_INLINE_QUERY_CONCURRENCY)
-    : 5;
-let currentInlineQueries = 0;
-const INLINE_QUERY_DEBOUNCE_INTERVAL = 2000; // ms
-const inlineQueryCache = {};
-// Helper to download a file URL and convert it to base64
-async function downloadFileAsBase64(fileUrl) {
-    return new Promise((resolve, reject) => {
-        https
-            .get(fileUrl, (res) => {
-            if (res.statusCode && res.statusCode >= 400) {
-                return reject(new Error(`Failed to download file: ${res.statusCode} ${res.statusMessage}`));
-            }
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => {
-                const buffer = Buffer.concat(chunks);
-                const contentType = res.headers['content-type'] || 'application/octet-stream';
-                resolve({ base64: buffer.toString('base64'), mimeType: contentType });
-            });
-        })
-            .on('error', reject);
-    });
-}
-// Insert initTelegramBot to wire up a TelegramBot given pre-initialized services
-export function startTelegramBot(agent) {
-    if (!token) {
-        throw new Error('TELEGRAM_BOT_TOKEN is not set');
-    }
-    const agentEventBus = agent.agentEventBus;
-    // Create and start Telegram Bot
-    const bot = new Bot(token);
-    console.log('Telegram bot started');
-    // Helper to get or create session for a Telegram user
-    // Each Telegram user gets their own persistent session
-    function getTelegramSessionId(userId) {
-        return `telegram-${userId}`;
-    }
-    // /start command with sample buttons
-    bot.command('start', async (ctx) => {
-        const keyboard = new InlineKeyboard()
-            .text('🔄 Reset Conversation', 'reset')
-            .row()
-            .text('❓ Help', 'help');
-        await ctx.reply('Welcome to Dexto AI Bot! Choose an option below:', {
-            reply_markup: keyboard,
-        });
-    });
-    // Handle button callbacks
-    bot.on('callback_query:data', async (ctx) => {
-        const action = ctx.callbackQuery.data;
-        const sessionId = getTelegramSessionId(ctx.callbackQuery.from.id);
-        try {
-            if (action === 'reset') {
-                await agent.resetConversation(sessionId);
-                await ctx.reply('🔄 Conversation has been reset.');
-            }
-            else if (action === 'help') {
-                await ctx.reply('Send me text or images and I will respond.');
-            }
-            await ctx.answerCallbackQuery();
-        }
-        catch (error) {
-            console.error('Error handling callback query', error);
-            // Attempt to notify user of the error
-            try {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                await ctx.reply(`Error processing request: ${errorMessage}`);
-            }
-            catch (e) {
-                console.error('Failed to send error message for callback query', e);
-            }
-        }
-    });
-    // Group chat slash command: /ask <your question>
-    bot.command('ask', async (ctx) => {
-        const question = ctx.match;
-        if (!question) {
-            ctx.reply('Please provide a question, e.g. `/ask How do I ...?`', {
-                parse_mode: 'Markdown',
-            });
-            return;
-        }
-        if (!ctx.from) {
-            logger.error('Telegram /ask command received without from field');
-            return;
-        }
-        const sessionId = getTelegramSessionId(ctx.from.id);
-        try {
-            await ctx.replyWithChatAction('typing');
-            const answer = await agent.run(question, undefined, undefined, sessionId);
-            if (answer) {
-                await ctx.reply(answer);
-            }
-            else {
-                await ctx.reply('🤖 …agent failed to respond');
-            }
-        }
-        catch (err) {
-            console.error('Error handling /ask command', err);
-            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-            await ctx.reply(`Error: ${errorMessage}`);
-        }
-    });
-    // Inline query handler
-    bot.on('inline_query', async (ctx) => {
-        const query = ctx.inlineQuery.query;
-        if (!query) {
-            return;
-        }
-        const userId = ctx.inlineQuery.from.id;
-        const queryText = query.trim();
-        const cacheKey = `${userId}:${queryText}`;
-        const now = Date.now();
-        // Debounce: return cached results if query repeated within interval
-        const cached = inlineQueryCache[cacheKey];
-        if (cached && now - cached.timestamp < INLINE_QUERY_DEBOUNCE_INTERVAL) {
-            ctx.answerInlineQuery(cached.results);
-            return;
-        }
-        // Concurrency cap
-        if (currentInlineQueries >= MAX_CONCURRENT_INLINE_QUERIES) {
-            // Too many concurrent inline queries; respond with empty list
-            ctx.answerInlineQuery([]);
-            return;
-        }
-        currentInlineQueries++;
-        try {
-            const sessionId = getTelegramSessionId(userId);
-            const queryTimeout = 15000; // 15 seconds timeout
-            const resultText = await Promise.race([
-                agent.run(query, undefined, undefined, sessionId),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Query timed out')), queryTimeout)),
-            ]);
-            const results = [
-                {
-                    type: 'article',
-                    id: ctx.inlineQuery.id,
-                    title: 'AI Answer',
-                    input_message_content: { message_text: resultText || 'No response' },
-                    description: (resultText || 'No response').substring(0, 100),
-                },
-            ];
-            // Cache the results
-            inlineQueryCache[cacheKey] = { timestamp: now, results };
-            await ctx.answerInlineQuery(results);
-        }
-        catch (error) {
-            console.error('Error handling inline query', error);
-            // Inform user about the error through inline results
-            try {
-                await ctx.answerInlineQuery([
-                    {
-                        type: 'article',
-                        id: ctx.inlineQuery.id,
-                        title: 'Error processing query',
-                        input_message_content: {
-                            message_text: `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                        },
-                        description: 'Error occurred while processing your request',
-                    },
-                ]);
-            }
-            catch (e) {
-                console.error('Failed to send inline query error', e);
-            }
-        }
-        finally {
-            currentInlineQueries--;
-        }
-    });
-    // Message handler with image support and toolCall notifications
-    bot.on('message', async (ctx) => {
-        let userText = ctx.message.text;
-        let imageDataInput;
-        try {
-            // Detect image messages
-            if (ctx.message.photo && ctx.message.photo.length > 0) {
-                const photo = ctx.message.photo[ctx.message.photo.length - 1];
-                const file = await ctx.api.getFile(photo.file_id);
-                const fileUrl = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
-                const { base64, mimeType } = await downloadFileAsBase64(fileUrl);
-                imageDataInput = { image: base64, mimeType };
-                userText = ctx.message.caption || ''; // Use caption if available
-            }
-        }
-        catch (err) {
-            console.error('Failed to process attached image in Telegram bot', err);
-            try {
-                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-                await ctx.reply(`🖼️ Error downloading or processing image: ${errorMessage}`);
-            }
-            catch (sendError) {
-                console.error('Failed to send image error message to user', sendError);
-            }
-            return; // Stop processing if image handling fails
-        }
-        // If there's no text (even after checking caption for photos) AND no image data, then nothing to process.
-        if (!userText && !imageDataInput)
-            return;
-        // If userText is undefined (e.g. only an image was sent with no caption) and no image was processed (e.g. due to an error caught above, though `return` should prevent this)
-        // or simply no text was ever present and no image.
-        if (userText === undefined && !imageDataInput)
-            return;
-        // Get session for this user
-        // ctx.from can be undefined for channel posts or anonymous admin messages
-        // We require user context for session isolation - don't use chat ID as it would
-        // cause multiple users in a group to share the same session (breaks isolation)
-        if (!ctx.from) {
-            logger.debug('Telegram message without user context (channel post or anonymous admin); skipping');
-            return;
-        }
-        const sessionId = getTelegramSessionId(ctx.from.id);
-        // Subscribe for toolCall events
-        const toolCallHandler = (payload) => {
-            // Filter by sessionId to avoid cross-session leakage
-            if (payload.sessionId !== sessionId)
-                return;
-            ctx.reply(`Calling *${payload.toolName}* with args: ${JSON.stringify(payload.args)}`, {
-                parse_mode: 'Markdown',
-            });
-        };
-        agentEventBus.on('llm:tool-call', toolCallHandler);
-        try {
-            await ctx.replyWithChatAction('typing');
-            const responseText = await agent.run(userText || '', imageDataInput, undefined, sessionId);
-            await ctx.reply(responseText || 'No response generated');
-        }
-        catch (error) {
-            console.error('Error handling Telegram message', error);
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            await ctx.reply(`Error: ${errorMessage}`);
-        }
-        finally {
-            agentEventBus.off('llm:tool-call', toolCallHandler);
-        }
-    });
-    // Start the bot
-    bot.start();
-    return bot;
-}