cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/telegram.js

@@ -0,0 +1,1390 @@
+"use strict";
+/**
+ * Telegram Channel Adapter
+ *
+ * Implements the ChannelAdapter interface using grammY for Telegram Bot API.
+ * Supports both polling and webhook modes.
+ *
+ * Features:
+ * - API throttling to prevent rate limits
+ * - Message deduplication to prevent double processing
+ * - Text fragment assembly for split long messages
+ * - ACK reactions while processing
+ * - Draft streaming for real-time response preview
+ * - Sequential message processing to prevent race conditions
+ * - Connection conflict detection (409 errors)
+ * - Exponential backoff with jitter for error recovery
+ * - Health check endpoint for webhook mode
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAdapter = void 0;
+exports.createTelegramAdapter = createTelegramAdapter;
+const grammy_1 = require("grammy");
+const runner_1 = require("@grammyjs/runner");
+const transformer_throttler_1 = require("@grammyjs/transformer-throttler");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+class TelegramAdapter {
+    constructor(config) {
+        this.type = 'telegram';
+        this.bot = null;
+        this._status = 'disconnected';
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.statusHandlers = [];
+        this.callbackQueryHandlers = [];
+        // Message deduplication: track processed update IDs
+        this.processedUpdates = new Map(); // updateId -> timestamp
+        this.DEDUP_CACHE_TTL = 60000; // 1 minute
+        this.DEDUP_CACHE_MAX_SIZE = 1000;
+        // Text fragment assembly: buffer split messages
+        this.pendingFragments = new Map(); // chatId:userId -> fragment
+        this.DEFAULT_FRAGMENT_TIMEOUT = 1500; // 1.5 seconds
+        // Draft streaming state
+        this.draftStates = new Map(); // chatId -> draft state
+        this.DRAFT_UPDATE_INTERVAL = 500; // Update draft every 500ms
+        // Exponential backoff state
+        this.backoffAttempt = 0;
+        this.isReconnecting = false;
+        // Default backoff configuration
+        this.DEFAULT_BACKOFF = {
+            initialDelay: 2000,
+            maxDelay: 30000,
+            multiplier: 1.8,
+            jitter: 0.25,
+            maxAttempts: 10,
+        };
+        /**
+         * Get sequential key for message ordering
+         * Messages from the same chat are processed sequentially
+         */
+        this.getSequentialKey = (ctx) => {
+            const chatId = ctx.chat?.id;
+            if (!chatId)
+                return undefined;
+            // Use chat ID + thread ID for forum topics
+            const threadId = ctx.message?.message_thread_id;
+            if (threadId) {
+                return `${chatId}:${threadId}`;
+            }
+            return String(chatId);
+        };
+        this.config = {
+            deduplicationEnabled: true,
+            ackReactionEnabled: true,
+            draftStreamingEnabled: true,
+            fragmentAssemblyTimeout: 1500,
+            sequentialProcessingEnabled: true,
+            ...config,
+        };
+    }
+    get status() {
+        return this._status;
+    }
+    get botUsername() {
+        return this._botUsername;
+    }
+    /**
+     * Connect to Telegram using long polling
+     */
+    async connect() {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        this.resetBackoff();
+        try {
+            // Create bot instance
+            this.bot = new grammy_1.Bot(this.config.botToken);
+            // Add API throttling to prevent rate limits
+            const throttler = (0, transformer_throttler_1.apiThrottler)();
+            this.bot.api.config.use(throttler);
+            // Add sequential processing to prevent race conditions
+            if (this.config.sequentialProcessingEnabled) {
+                this.bot.use((0, runner_1.sequentialize)(this.getSequentialKey));
+            }
+            // Get bot info
+            const me = await this.bot.api.getMe();
+            this._botUsername = me.username;
+            // Register expanded bot commands for the "/" menu
+            await this.registerBotCommands();
+            // Set up message handler with deduplication and fragment assembly
+            this.bot.on('message:text', async (ctx) => {
+                await this.handleTextMessage(ctx);
+            });
+            // Set up callback query handler for inline keyboards
+            this.bot.on('callback_query:data', async (ctx) => {
+                await this.handleCallbackQuery(ctx);
+            });
+            // Handle errors with 409 detection and backoff
+            this.bot.catch(async (err) => {
+                await this.handleBotError(err);
+            });
+            // Start deduplication cleanup timer
+            if (this.config.deduplicationEnabled) {
+                this.startDedupCleanup();
+            }
+            // Start polling with error handling
+            await this.startPolling();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Check for connection conflict (409) during initial connection
+            if (this.isConnectionConflictError(error)) {
+                console.error('Connection conflict detected: Another bot instance is running');
+                this.setStatus('error', new Error('Connection conflict: Another bot instance is running. Stop the other instance first.'));
+                throw new Error('Connection conflict: Another bot instance is running');
+            }
+            this.setStatus('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Register bot commands for the "/" menu
+     */
+    async registerBotCommands() {
+        if (!this.bot)
+            return;
+        await this.bot.api.setMyCommands([
+            // Core commands
+            { command: 'start', description: 'Start the bot and see welcome message' },
+            { command: 'help', description: 'Show all available commands' },
+            { command: 'status', description: 'Check bot connection and system status' },
+            // Workspace management
+            { command: 'workspaces', description: 'List all available workspaces' },
+            { command: 'workspace', description: 'Select or show current workspace' },
+            { command: 'addworkspace', description: 'Add a new workspace by path' },
+            { command: 'removeworkspace', description: 'Remove a workspace from the list' },
+            // Task management
+            { command: 'newtask', description: 'Start a fresh task/conversation' },
+            { command: 'cancel', description: 'Cancel the current running task' },
+            { command: 'retry', description: 'Retry the last failed task' },
+            { command: 'history', description: 'Show recent task history' },
+            // Model configuration
+            { command: 'provider', description: 'Change or show current LLM provider' },
+            { command: 'providers', description: 'List all available LLM providers' },
+            { command: 'model', description: 'Change or show current model' },
+            { command: 'models', description: 'List available AI models' },
+            // Skills management
+            { command: 'skills', description: 'List available skills' },
+            { command: 'skill', description: 'Enable or disable a skill' },
+            // Settings
+            { command: 'settings', description: 'View and modify bot settings' },
+            { command: 'debug', description: 'Toggle debug mode on/off' },
+            { command: 'version', description: 'Show bot version information' },
+        ]);
+    }
+    /**
+     * Start polling with error handling and reconnection
+     */
+    async startPolling() {
+        if (!this.bot)
+            return;
+        this.bot.start({
+            onStart: () => {
+                console.log(`Telegram bot @${this._botUsername} started`);
+                this.setStatus('connected');
+                this.resetBackoff();
+            },
+            drop_pending_updates: true,
+            allowed_updates: ['message', 'message_reaction', 'callback_query'],
+        });
+    }
+    /**
+     * Handle bot errors including 409 conflict detection
+     */
+    async handleBotError(err) {
+        console.error('Telegram bot error:', err);
+        // Check for connection conflict (409)
+        if (this.isConnectionConflictError(err)) {
+            console.error('Connection conflict detected (409): Another bot instance may be running');
+            this.setStatus('error', new Error('Connection conflict: Another bot instance is running'));
+            // Don't reconnect on 409 - let the user resolve the conflict
+            this.handleError(new Error('Connection conflict: Another bot instance is running. Stop the other instance and restart.'), 'connection_conflict');
+            return;
+        }
+        // Check for network errors that warrant reconnection
+        if (this.isNetworkError(err)) {
+            console.log('Network error detected, will attempt reconnection with backoff');
+            await this.attemptReconnection();
+            return;
+        }
+        // Handle other errors normally
+        this.handleError(err instanceof Error ? err : new Error(String(err)), 'bot.catch');
+    }
+    /**
+     * Check if error is a connection conflict (409)
+     */
+    isConnectionConflictError(err) {
+        if (err instanceof grammy_1.GrammyError) {
+            return err.error_code === 409;
+        }
+        if (err instanceof grammy_1.HttpError) {
+            return err.status === 409;
+        }
+        // Check error message for 409 indicators
+        const message = err instanceof Error ? err.message : String(err);
+        return message.includes('409') || message.includes('Conflict') || message.includes('terminated by other getUpdates');
+    }
+    /**
+     * Check if error is a network error that warrants reconnection
+     */
+    isNetworkError(err) {
+        if (err instanceof grammy_1.HttpError) {
+            return true;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return (message.includes('ECONNRESET') ||
+            message.includes('ETIMEDOUT') ||
+            message.includes('ENOTFOUND') ||
+            message.includes('network') ||
+            message.includes('socket') ||
+            message.includes('502') ||
+            message.includes('503') ||
+            message.includes('504'));
+    }
+    /**
+     * Attempt reconnection with exponential backoff
+     */
+    async attemptReconnection() {
+        if (this.isReconnecting) {
+            console.log('Reconnection already in progress');
+            return;
+        }
+        const backoffConfig = { ...this.DEFAULT_BACKOFF, ...this.config.backoff };
+        if (this.backoffAttempt >= backoffConfig.maxAttempts) {
+            console.error(`Max reconnection attempts (${backoffConfig.maxAttempts}) reached`);
+            this.setStatus('error', new Error('Max reconnection attempts reached'));
+            this.handleError(new Error('Failed to reconnect after maximum attempts'), 'reconnection_failed');
+            return;
+        }
+        this.isReconnecting = true;
+        this.backoffAttempt++;
+        const delay = this.calculateBackoffDelay(backoffConfig);
+        console.log(`Reconnection attempt ${this.backoffAttempt}/${backoffConfig.maxAttempts} in ${delay}ms`);
+        this.backoffTimer = setTimeout(async () => {
+            try {
+                // Stop existing bot if any
+                if (this.bot) {
+                    await this.bot.stop();
+                    this.bot = null;
+                }
+                this.isReconnecting = false;
+                this.setStatus('disconnected');
+                // Attempt to reconnect
+                await this.connect();
+            }
+            catch (error) {
+                this.isReconnecting = false;
+                console.error('Reconnection attempt failed:', error);
+                // Schedule next attempt if not a 409 conflict
+                if (!this.isConnectionConflictError(error)) {
+                    await this.attemptReconnection();
+                }
+            }
+        }, delay);
+    }
+    /**
+     * Calculate backoff delay with jitter
+     */
+    calculateBackoffDelay(config) {
+        // Calculate base delay: initialDelay * multiplier^attempt
+        let delay = config.initialDelay * Math.pow(config.multiplier, this.backoffAttempt - 1);
+        // Cap at max delay
+        delay = Math.min(delay, config.maxDelay);
+        // Add jitter: delay ± (delay * jitter * random)
+        const jitterAmount = delay * config.jitter;
+        const jitter = (Math.random() * 2 - 1) * jitterAmount; // Random between -jitterAmount and +jitterAmount
+        delay = Math.round(delay + jitter);
+        // Ensure minimum delay of 1 second
+        return Math.max(1000, delay);
+    }
+    /**
+     * Reset backoff state
+     */
+    resetBackoff() {
+        this.backoffAttempt = 0;
+        this.isReconnecting = false;
+        if (this.backoffTimer) {
+            clearTimeout(this.backoffTimer);
+            this.backoffTimer = undefined;
+        }
+    }
+    /**
+     * Handle incoming text message with deduplication and fragment assembly
+     */
+    async handleTextMessage(ctx) {
+        const msg = ctx.message;
+        const updateId = ctx.update.update_id;
+        // Feature 4: Message deduplication - check if already processed
+        if (this.config.deduplicationEnabled && this.isUpdateProcessed(updateId)) {
+            console.log(`Skipping duplicate update ${updateId}`);
+            return;
+        }
+        // Mark update as processed
+        if (this.config.deduplicationEnabled) {
+            this.markUpdateProcessed(updateId);
+        }
+        // Feature 3: Text fragment assembly - buffer split messages
+        const fragmentKey = `${msg.chat.id}:${msg.from.id}`;
+        const existingFragment = this.pendingFragments.get(fragmentKey);
+        if (existingFragment) {
+            // Add to existing fragment
+            clearTimeout(existingFragment.timer);
+            existingFragment.messages.push({
+                messageId: msg.message_id.toString(),
+                text: msg.text || '',
+                timestamp: new Date(msg.date * 1000),
+                ctx,
+            });
+            // Reset timer
+            existingFragment.timer = setTimeout(() => {
+                this.processFragments(fragmentKey);
+            }, this.config.fragmentAssemblyTimeout || this.DEFAULT_FRAGMENT_TIMEOUT);
+        }
+        else {
+            // Check if this might be a split message (long text arriving in chunks)
+            // Telegram splits messages at ~4096 chars, so check if message ends mid-sentence
+            const mightBeSplit = this.mightBeSplitMessage(msg.text || '');
+            if (mightBeSplit) {
+                // Start new fragment buffer
+                const timer = setTimeout(() => {
+                    this.processFragments(fragmentKey);
+                }, this.config.fragmentAssemblyTimeout || this.DEFAULT_FRAGMENT_TIMEOUT);
+                this.pendingFragments.set(fragmentKey, {
+                    chatId: msg.chat.id.toString(),
+                    userId: msg.from.id.toString(),
+                    messages: [{
+                            messageId: msg.message_id.toString(),
+                            text: msg.text || '',
+                            timestamp: new Date(msg.date * 1000),
+                            ctx,
+                        }],
+                    timer,
+                });
+            }
+            else {
+                // Process immediately (single message)
+                await this.processMessage(ctx);
+            }
+        }
+    }
+    /**
+     * Check if a message might be part of a split message
+     */
+    mightBeSplitMessage(text) {
+        // Messages near Telegram's limit or ending abruptly might be split
+        if (text.length >= 4000)
+            return true;
+        // Check if text ends mid-sentence (no terminal punctuation)
+        const trimmed = text.trim();
+        if (trimmed.length > 100) {
+            const lastChar = trimmed.charAt(trimmed.length - 1);
+            const terminalPunctuation = ['.', '!', '?', ')', ']', '}', '"', "'", '`'];
+            if (!terminalPunctuation.includes(lastChar)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Process assembled fragments
+     */
+    async processFragments(fragmentKey) {
+        const fragment = this.pendingFragments.get(fragmentKey);
+        if (!fragment)
+            return;
+        this.pendingFragments.delete(fragmentKey);
+        if (fragment.messages.length === 1) {
+            // Single message, process normally
+            await this.processMessage(fragment.messages[0].ctx);
+        }
+        else {
+            // Multiple messages, combine them
+            const combinedText = fragment.messages
+                .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())
+                .map(m => m.text)
+                .join('');
+            // Use the first message's context but with combined text
+            const firstCtx = fragment.messages[0].ctx;
+            const message = this.mapContextToMessage(firstCtx, combinedText);
+            console.log(`Assembled ${fragment.messages.length} text fragments into single message (${combinedText.length} chars)`);
+            await this.handleIncomingMessage(message);
+        }
+    }
+    /**
+     * Process a single message (with ACK reaction)
+     */
+    async processMessage(ctx) {
+        const message = this.mapContextToMessage(ctx);
+        // Feature 2: Send ACK reaction (👀) while processing
+        if (this.config.ackReactionEnabled) {
+            try {
+                await this.sendAckReaction(ctx);
+            }
+            catch (err) {
+                // Ignore reaction errors (might not have permission)
+                console.debug('Could not send ACK reaction:', err);
+            }
+        }
+        await this.handleIncomingMessage(message);
+    }
+    /**
+     * Send ACK reaction (👀) to indicate message received
+     */
+    async sendAckReaction(ctx) {
+        if (!this.bot || !ctx.message)
+            return;
+        try {
+            await this.bot.api.setMessageReaction(ctx.message.chat.id, ctx.message.message_id, [{ type: 'emoji', emoji: '👀' }]);
+        }
+        catch {
+            // Silently fail - reactions might not be available
+        }
+    }
+    /**
+     * Remove ACK reaction after processing
+     */
+    async removeAckReaction(chatId, messageId) {
+        if (!this.bot)
+            return;
+        try {
+            await this.bot.api.setMessageReaction(chatId, parseInt(messageId, 10), [] // Empty array removes reactions
+            );
+        }
+        catch {
+            // Silently fail
+        }
+    }
+    /**
+     * Send a completion reaction when done
+     * Note: Telegram only allows specific reaction emojis, using 👍 for completion
+     */
+    async sendCompletionReaction(chatId, messageId) {
+        if (!this.bot)
+            return;
+        try {
+            await this.bot.api.setMessageReaction(chatId, parseInt(messageId, 10), [{ type: 'emoji', emoji: '👍' }]);
+        }
+        catch {
+            // Silently fail
+        }
+    }
+    /**
+     * Check if update was already processed (deduplication)
+     */
+    isUpdateProcessed(updateId) {
+        return this.processedUpdates.has(updateId);
+    }
+    /**
+     * Mark update as processed
+     */
+    markUpdateProcessed(updateId) {
+        this.processedUpdates.set(updateId, Date.now());
+        // Prevent unbounded growth
+        if (this.processedUpdates.size > this.DEDUP_CACHE_MAX_SIZE) {
+            this.cleanupDedupCache();
+        }
+    }
+    /**
+     * Start periodic cleanup of dedup cache
+     */
+    startDedupCleanup() {
+        this.dedupCleanupTimer = setInterval(() => {
+            this.cleanupDedupCache();
+        }, this.DEDUP_CACHE_TTL);
+    }
+    /**
+     * Clean up old entries from dedup cache
+     */
+    cleanupDedupCache() {
+        const now = Date.now();
+        for (const [updateId, timestamp] of this.processedUpdates) {
+            if (now - timestamp > this.DEDUP_CACHE_TTL) {
+                this.processedUpdates.delete(updateId);
+            }
+        }
+    }
+    /**
+     * Disconnect from Telegram
+     */
+    async disconnect() {
+        // Reset backoff state
+        this.resetBackoff();
+        // Clear timers
+        if (this.dedupCleanupTimer) {
+            clearInterval(this.dedupCleanupTimer);
+            this.dedupCleanupTimer = undefined;
+        }
+        // Clear pending fragments
+        for (const fragment of this.pendingFragments.values()) {
+            clearTimeout(fragment.timer);
+        }
+        this.pendingFragments.clear();
+        // Clear draft states
+        this.draftStates.clear();
+        // Clear dedup cache
+        this.processedUpdates.clear();
+        // Stop webhook server if running
+        if (this.webhookServer) {
+            await this.stopWebhookServer();
+        }
+        if (this.bot) {
+            await this.bot.stop();
+            this.bot = null;
+        }
+        this._botUsername = undefined;
+        this.setStatus('disconnected');
+    }
+    /**
+     * Send a message to a Telegram chat
+     */
+    async sendMessage(message) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        // Handle image attachments first (send images before text)
+        let lastMessageId;
+        if (message.attachments && message.attachments.length > 0) {
+            for (const attachment of message.attachments) {
+                if (attachment.type === 'image' && attachment.url) {
+                    try {
+                        // attachment.url is the file path for local images
+                        const msgId = await this.sendPhoto(message.chatId, attachment.url);
+                        lastMessageId = msgId;
+                    }
+                    catch (err) {
+                        console.error('Failed to send image attachment:', err);
+                    }
+                }
+            }
+        }
+        // If we have text to send, send it
+        if (message.text && message.text.trim()) {
+            // Process text for Telegram compatibility
+            let processedText = message.text;
+            if (message.parseMode === 'markdown') {
+                processedText = this.convertMarkdownForTelegram(message.text);
+            }
+            const options = {};
+            // Set parse mode
+            // Use legacy Markdown (not MarkdownV2) to avoid escaping issues with special characters
+            if (message.parseMode === 'markdown') {
+                options.parse_mode = 'Markdown';
+            }
+            else if (message.parseMode === 'html') {
+                options.parse_mode = 'HTML';
+            }
+            // Reply to message if specified
+            if (message.replyTo) {
+                options.reply_to_message_id = parseInt(message.replyTo, 10);
+            }
+            // Forum topic thread support
+            if (message.threadId) {
+                options.message_thread_id = parseInt(message.threadId, 10);
+            }
+            // Link preview control
+            if (message.disableLinkPreview) {
+                options.link_preview_options = { is_disabled: true };
+            }
+            // Inline keyboard support
+            if (message.inlineKeyboard && message.inlineKeyboard.length > 0) {
+                options.reply_markup = this.buildInlineKeyboard(message.inlineKeyboard);
+            }
+            try {
+                const sent = await this.bot.api.sendMessage(message.chatId, processedText, options);
+                return sent.message_id.toString();
+            }
+            catch (error) {
+                // If markdown parsing fails, retry without parse_mode
+                if (error?.error_code === 400 && error?.description?.includes("can't parse entities")) {
+                    console.log('Markdown parsing failed, retrying without parse_mode');
+                    const plainOptions = {
+                        ...(message.threadId && { message_thread_id: parseInt(message.threadId, 10) }),
+                        ...(message.disableLinkPreview && { link_preview_options: { is_disabled: true } }),
+                        ...(message.inlineKeyboard && { reply_markup: this.buildInlineKeyboard(message.inlineKeyboard) }),
+                    };
+                    if (message.replyTo) {
+                        plainOptions.reply_to_message_id = parseInt(message.replyTo, 10);
+                    }
+                    const sent = await this.bot.api.sendMessage(message.chatId, message.text, plainOptions);
+                    return sent.message_id.toString();
+                }
+                throw error;
+            }
+        }
+        // If no text but had attachments, return the last attachment message ID
+        return lastMessageId || '';
+    }
+    /**
+     * Build grammY InlineKeyboard from our button format
+     */
+    buildInlineKeyboard(buttons) {
+        const keyboard = new grammy_1.InlineKeyboard();
+        for (const row of buttons) {
+            for (const button of row) {
+                if (button.url) {
+                    keyboard.url(button.text, button.url);
+                }
+                else if (button.callbackData) {
+                    keyboard.text(button.text, button.callbackData);
+                }
+            }
+            keyboard.row();
+        }
+        return keyboard;
+    }
+    /**
+     * Handle incoming callback query from inline keyboard button press
+     */
+    async handleCallbackQuery(ctx) {
+        const query = ctx.callbackQuery;
+        if (!query.data || !query.message) {
+            return;
+        }
+        const callbackQuery = {
+            id: query.id,
+            userId: query.from.id.toString(),
+            userName: query.from.first_name + (query.from.last_name ? ` ${query.from.last_name}` : ''),
+            chatId: query.message.chat.id.toString(),
+            messageId: query.message.message_id.toString(),
+            data: query.data,
+            threadId: query.message.message_thread_id?.toString(),
+            raw: ctx,
+        };
+        // Notify all registered handlers
+        for (const handler of this.callbackQueryHandlers) {
+            try {
+                await handler(callbackQuery);
+            }
+            catch (error) {
+                console.error('Error in callback query handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'callbackQueryHandler');
+            }
+        }
+    }
+    /**
+     * Feature 1: Draft streaming - Start streaming a response
+     * Creates or updates a draft message that shows response as it generates
+     */
+    async startDraftStream(chatId) {
+        if (!this.config.draftStreamingEnabled)
+            return;
+        this.draftStates.set(chatId, {
+            chatId,
+            currentText: '',
+            lastUpdateTime: Date.now(),
+        });
+    }
+    /**
+     * Update draft stream with new content
+     */
+    async updateDraftStream(chatId, text) {
+        if (!this.bot || !this.config.draftStreamingEnabled)
+            return;
+        const state = this.draftStates.get(chatId);
+        if (!state)
+            return;
+        const now = Date.now();
+        // Throttle updates to prevent API spam
+        if (now - state.lastUpdateTime < this.DRAFT_UPDATE_INTERVAL) {
+            // Just update the text, don't send yet
+            state.currentText = text;
+            return;
+        }
+        // Add typing indicator suffix
+        const displayText = text + ' ▌';
+        try {
+            if (state.messageId) {
+                // Edit existing message
+                await this.bot.api.editMessageText(chatId, parseInt(state.messageId, 10), displayText);
+            }
+            else {
+                // Create new message
+                const sent = await this.bot.api.sendMessage(chatId, displayText);
+                state.messageId = sent.message_id.toString();
+            }
+            state.currentText = text;
+            state.lastUpdateTime = now;
+        }
+        catch (error) {
+            // Ignore "message not modified" errors
+            if (!error?.description?.includes('message is not modified')) {
+                console.error('Draft stream update error:', error);
+            }
+        }
+    }
+    /**
+     * Finalize draft stream with final content
+     */
+    async finalizeDraftStream(chatId, finalText) {
+        if (!this.bot)
+            throw new Error('Bot not connected');
+        const state = this.draftStates.get(chatId);
+        this.draftStates.delete(chatId);
+        if (!this.config.draftStreamingEnabled || !state?.messageId) {
+            // No draft exists, send as new message
+            const sent = await this.bot.api.sendMessage(chatId, finalText);
+            return sent.message_id.toString();
+        }
+        try {
+            // Edit the draft message to final content (remove typing indicator)
+            await this.bot.api.editMessageText(chatId, parseInt(state.messageId, 10), finalText);
+            return state.messageId;
+        }
+        catch (error) {
+            // If edit fails, send as new message
+            console.error('Failed to finalize draft, sending new message:', error);
+            const sent = await this.bot.api.sendMessage(chatId, finalText);
+            return sent.message_id.toString();
+        }
+    }
+    /**
+     * Cancel draft stream (delete the draft message)
+     */
+    async cancelDraftStream(chatId) {
+        const state = this.draftStates.get(chatId);
+        this.draftStates.delete(chatId);
+        if (state?.messageId && this.bot) {
+            try {
+                await this.bot.api.deleteMessage(chatId, parseInt(state.messageId, 10));
+            }
+            catch {
+                // Ignore deletion errors
+            }
+        }
+    }
+    /**
+     * Convert GitHub-flavored markdown to Telegram-compatible format
+     * Telegram legacy Markdown only supports: *bold*, _italic_, `code`, ```code blocks```, [links](url)
+     */
+    convertMarkdownForTelegram(text) {
+        let result = text;
+        // Convert markdown headers (## Header) to bold (*Header*)
+        // Must be done before ** conversion
+        result = result.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+        // Convert markdown tables to code blocks
+        // Tables start with | and have a separator line like |---|---|
+        const tableRegex = /(\|[^\n]+\|\n)+/g;
+        const hasSeparatorLine = /\|[\s-:]+\|/;
+        result = result.replace(tableRegex, (match) => {
+            // Check if this looks like a table (has separator line with dashes)
+            if (hasSeparatorLine.test(match)) {
+                // Convert table to code block for monospace display
+                // Remove the separator line (|---|---|) as it's just formatting
+                const lines = match.split('\n').filter(line => line.trim());
+                const cleanedLines = lines.filter(line => !(/^\|[\s-:]+\|$/.test(line.trim())));
+                // Format table nicely
+                const formattedTable = cleanedLines.map(line => {
+                    // Remove leading/trailing pipes and clean up
+                    return line.replace(/^\||\|$/g, '').trim();
+                }).join('\n');
+                return '```\n' + formattedTable + '\n```\n';
+            }
+            return match;
+        });
+        // Convert **bold** to *bold* (Telegram uses single asterisk)
+        result = result.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+        // Convert __bold__ to *bold* (alternative bold syntax)
+        result = result.replace(/__([^_]+)__/g, '*$1*');
+        // Convert horizontal rules (---, ***) to a line
+        result = result.replace(/^[-*]{3,}$/gm, '─────────────────');
+        return result;
+    }
+    /**
+     * Edit an existing message
+     */
+    async editMessage(chatId, messageId, text) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const msgId = parseInt(messageId, 10);
+        if (isNaN(msgId)) {
+            throw new Error(`Invalid message ID: ${messageId}`);
+        }
+        await this.bot.api.editMessageText(chatId, msgId, text);
+    }
+    /**
+     * Delete a message
+     */
+    async deleteMessage(chatId, messageId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const msgId = parseInt(messageId, 10);
+        if (isNaN(msgId)) {
+            throw new Error(`Invalid message ID: ${messageId}`);
+        }
+        await this.bot.api.deleteMessage(chatId, msgId);
+    }
+    /**
+     * Send a document/file to a chat
+     */
+    async sendDocument(chatId, filePath, caption) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const fileName = path.basename(filePath);
+        const fileBuffer = fs.readFileSync(filePath);
+        const sent = await this.bot.api.sendDocument(chatId, new grammy_1.InputFile(fileBuffer, fileName), { caption });
+        return sent.message_id.toString();
+    }
+    /**
+     * Send a photo/image to a chat
+     */
+    async sendPhoto(chatId, filePath, caption) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const fileName = path.basename(filePath);
+        const fileBuffer = fs.readFileSync(filePath);
+        const sent = await this.bot.api.sendPhoto(chatId, new grammy_1.InputFile(fileBuffer, fileName), { caption });
+        return sent.message_id.toString();
+    }
+    /**
+     * Register a message handler
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a callback query handler (for inline keyboard buttons)
+     */
+    onCallbackQuery(handler) {
+        this.callbackQueryHandlers.push(handler);
+    }
+    /**
+     * Answer a callback query (acknowledge button press)
+     * Call this to remove the loading state from the button.
+     */
+    async answerCallbackQuery(queryId, text, showAlert) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        await this.bot.api.answerCallbackQuery(queryId, {
+            text,
+            show_alert: showAlert,
+        });
+    }
+    /**
+     * Edit a message with a new inline keyboard
+     */
+    async editMessageWithKeyboard(chatId, messageId, text, inlineKeyboard) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const msgId = parseInt(messageId, 10);
+        if (isNaN(msgId)) {
+            throw new Error(`Invalid message ID: ${messageId}`);
+        }
+        const options = {};
+        if (inlineKeyboard && inlineKeyboard.length > 0) {
+            options.reply_markup = this.buildInlineKeyboard(inlineKeyboard);
+        }
+        if (text) {
+            await this.bot.api.editMessageText(chatId, msgId, text, options);
+        }
+        else if (inlineKeyboard) {
+            await this.bot.api.editMessageReplyMarkup(chatId, msgId, options);
+        }
+    }
+    // ============================================================================
+    // Extended Features
+    // ============================================================================
+    /**
+     * Send typing indicator (chat action)
+     */
+    async sendTyping(chatId, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const options = {};
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        await this.bot.api.sendChatAction(chatId, 'typing', options);
+    }
+    /**
+     * Add reaction to a message
+     */
+    async addReaction(chatId, messageId, emoji) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const msgId = parseInt(messageId, 10);
+        // Cast emoji to the expected type - Telegram will reject invalid emojis at runtime
+        await this.bot.api.setMessageReaction(chatId, msgId, [{ type: 'emoji', emoji: emoji }]);
+    }
+    /**
+     * Remove reaction from a message
+     */
+    async removeReaction(chatId, messageId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const msgId = parseInt(messageId, 10);
+        await this.bot.api.setMessageReaction(chatId, msgId, []);
+    }
+    /**
+     * Send a poll
+     */
+    async sendPoll(chatId, poll, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const options = {
+            is_anonymous: poll.isAnonymous ?? true,
+            allows_multiple_answers: poll.allowsMultipleAnswers ?? false,
+        };
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        if (poll.type === 'quiz' && poll.correctOptionId !== undefined) {
+            options.type = 'quiz';
+            options.correct_option_id = poll.correctOptionId;
+            if (poll.explanation) {
+                options.explanation = poll.explanation;
+            }
+        }
+        if (poll.openPeriod) {
+            options.open_period = poll.openPeriod;
+        }
+        else if (poll.closeDate) {
+            options.close_date = Math.floor(poll.closeDate.getTime() / 1000);
+        }
+        const sent = await this.bot.api.sendPoll(chatId, poll.question, poll.options.map(o => o.text), options);
+        return sent.message_id.toString();
+    }
+    /**
+     * Send message with reply keyboard (persistent keyboard below input)
+     */
+    async sendWithReplyKeyboard(chatId, text, keyboard, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const replyMarkup = {
+            keyboard: keyboard.buttons.map(row => row.map(btn => ({
+                text: btn.text,
+                request_contact: btn.requestContact,
+                request_location: btn.requestLocation,
+            }))),
+            resize_keyboard: keyboard.resizeKeyboard ?? true,
+            one_time_keyboard: keyboard.oneTimeKeyboard ?? false,
+            input_field_placeholder: keyboard.inputPlaceholder,
+        };
+        const options = {
+            reply_markup: replyMarkup,
+        };
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        const sent = await this.bot.api.sendMessage(chatId, text, options);
+        return sent.message_id.toString();
+    }
+    /**
+     * Remove reply keyboard (send message that hides the keyboard)
+     */
+    async removeReplyKeyboard(chatId, text, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const options = {
+            reply_markup: { remove_keyboard: true },
+        };
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        const sent = await this.bot.api.sendMessage(chatId, text, options);
+        return sent.message_id.toString();
+    }
+    /**
+     * Send a sticker
+     */
+    async sendSticker(chatId, stickerId, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const options = {};
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        const sent = await this.bot.api.sendSticker(chatId, stickerId, options);
+        return sent.message_id.toString();
+    }
+    /**
+     * Send location
+     */
+    async sendLocation(chatId, latitude, longitude, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const options = {};
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        const sent = await this.bot.api.sendLocation(chatId, latitude, longitude, options);
+        return sent.message_id.toString();
+    }
+    /**
+     * Send a media group (album)
+     */
+    async sendMediaGroup(chatId, media, threadId) {
+        if (!this.bot || this._status !== 'connected') {
+            throw new Error('Telegram bot is not connected');
+        }
+        const inputMedia = media.map((m, index) => {
+            const fileBuffer = fs.readFileSync(m.filePath);
+            const fileName = path.basename(m.filePath);
+            return {
+                type: m.type,
+                media: new grammy_1.InputFile(fileBuffer, fileName),
+                caption: index === 0 ? m.caption : undefined, // Caption on first item only
+            };
+        });
+        const options = {};
+        if (threadId) {
+            options.message_thread_id = parseInt(threadId, 10);
+        }
+        const sent = await this.bot.api.sendMediaGroup(chatId, inputMedia, options);
+        return sent.map(m => m.message_id.toString());
+    }
+    // ============================================================================
+    // Handler Registration
+    // ============================================================================
+    /**
+     * Register an error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Register a status change handler
+     */
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    /**
+     * Get channel info
+     */
+    async getInfo() {
+        let botId;
+        let botDisplayName;
+        if (this.bot && this._status === 'connected') {
+            try {
+                const me = await this.bot.api.getMe();
+                botId = me.id.toString();
+                botDisplayName = me.first_name;
+                this._botUsername = me.username;
+            }
+            catch {
+                // Ignore errors getting info
+            }
+        }
+        return {
+            type: 'telegram',
+            status: this._status,
+            botId,
+            botUsername: this._botUsername,
+            botDisplayName,
+        };
+    }
+    /**
+     * Get webhook callback for Express/Fastify/etc.
+     * Use this when running in webhook mode instead of polling.
+     */
+    getWebhookCallback() {
+        if (!this.bot) {
+            throw new Error('Bot not initialized');
+        }
+        return (0, grammy_1.webhookCallback)(this.bot, 'express');
+    }
+    /**
+     * Set webhook URL
+     */
+    async setWebhook(url, secretToken) {
+        if (!this.bot) {
+            throw new Error('Bot not initialized');
+        }
+        await this.bot.api.setWebhook(url, {
+            secret_token: secretToken,
+            allowed_updates: ['message'],
+        });
+    }
+    /**
+     * Remove webhook
+     */
+    async deleteWebhook() {
+        if (!this.bot) {
+            throw new Error('Bot not initialized');
+        }
+        await this.bot.api.deleteWebhook();
+    }
+    /**
+     * Start webhook server with health check endpoint
+     * This creates an HTTP server that handles both webhook callbacks and health checks.
+     */
+    async startWebhookServer(config) {
+        if (this.webhookServer) {
+            throw new Error('Webhook server is already running');
+        }
+        if (!this.bot) {
+            throw new Error('Bot not initialized. Call connect() first or initialize bot manually.');
+        }
+        const { port, host = '0.0.0.0', secretToken, webhookPath = '/webhook', healthPath = '/healthz', } = config;
+        // Create HTTP server
+        this.webhookServer = http.createServer(async (req, res) => {
+            const url = req.url || '/';
+            // Health check endpoint
+            if (req.method === 'GET' && url === healthPath) {
+                await this.handleHealthCheck(req, res);
+                return;
+            }
+            // Webhook endpoint
+            if (req.method === 'POST' && url === webhookPath) {
+                // Validate secret token if configured
+                if (secretToken) {
+                    const requestToken = req.headers['x-telegram-bot-api-secret-token'];
+                    if (requestToken !== secretToken) {
+                        res.writeHead(401, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Unauthorized' }));
+                        return;
+                    }
+                }
+                // Handle webhook callback
+                await this.handleWebhookRequest(req, res);
+                return;
+            }
+            // 404 for unknown routes
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        });
+        // Start listening
+        return new Promise((resolve, reject) => {
+            this.webhookServer.listen(port, host, () => {
+                console.log(`Telegram webhook server listening on ${host}:${port}`);
+                console.log(`  Webhook endpoint: ${webhookPath}`);
+                console.log(`  Health check: ${healthPath}`);
+                resolve();
+            });
+            this.webhookServer.on('error', (error) => {
+                console.error('Webhook server error:', error);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Stop the webhook server
+     */
+    async stopWebhookServer() {
+        if (!this.webhookServer) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.webhookServer.close(() => {
+                console.log('Webhook server stopped');
+                this.webhookServer = undefined;
+                resolve();
+            });
+        });
+    }
+    /**
+     * Handle health check requests
+     */
+    async handleHealthCheck(_req, res) {
+        const health = {
+            status: this._status === 'connected' ? 'healthy' : 'unhealthy',
+            timestamp: new Date().toISOString(),
+            bot: {
+                status: this._status,
+                username: this._botUsername || null,
+                connected: this._status === 'connected',
+            },
+            uptime: process.uptime(),
+            memory: process.memoryUsage(),
+        };
+        const statusCode = health.status === 'healthy' ? 200 : 503;
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(health, null, 2));
+    }
+    /**
+     * Handle webhook requests
+     */
+    async handleWebhookRequest(req, res) {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', async () => {
+            try {
+                const update = JSON.parse(body);
+                // Process the update using grammY's webhook handler
+                if (this.bot) {
+                    await this.bot.handleUpdate(update);
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            }
+            catch (error) {
+                console.error('Error processing webhook:', error);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Internal server error' }));
+            }
+        });
+    }
+    /**
+     * Connect using webhook mode instead of polling
+     * Sets up the bot, registers commands, and starts the webhook server.
+     */
+    async connectWithWebhook(webhookUrl, serverConfig) {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        this.resetBackoff();
+        try {
+            // Create bot instance
+            this.bot = new grammy_1.Bot(this.config.botToken);
+            // Add API throttling
+            const throttler = (0, transformer_throttler_1.apiThrottler)();
+            this.bot.api.config.use(throttler);
+            // Add sequential processing
+            if (this.config.sequentialProcessingEnabled) {
+                this.bot.use((0, runner_1.sequentialize)(this.getSequentialKey));
+            }
+            // Get bot info
+            const me = await this.bot.api.getMe();
+            this._botUsername = me.username;
+            // Register bot commands
+            await this.registerBotCommands();
+            // Set up message handler
+            this.bot.on('message:text', async (ctx) => {
+                await this.handleTextMessage(ctx);
+            });
+            // Handle errors
+            this.bot.catch(async (err) => {
+                await this.handleBotError(err);
+            });
+            // Start deduplication cleanup
+            if (this.config.deduplicationEnabled) {
+                this.startDedupCleanup();
+            }
+            // Start webhook server
+            await this.startWebhookServer(serverConfig);
+            // Set webhook URL with Telegram
+            await this.setWebhook(webhookUrl, serverConfig.secretToken);
+            console.log(`Telegram bot @${this._botUsername} connected via webhook`);
+            this.setStatus('connected');
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.setStatus('error', err);
+            throw err;
+        }
+    }
+    // Private methods
+    mapContextToMessage(ctx, overrideText) {
+        const msg = ctx.message;
+        const from = msg.from;
+        const chat = msg.chat;
+        // Check for forum topic (message_thread_id indicates a forum topic)
+        const threadId = msg.message_thread_id?.toString();
+        const isForumTopic = msg.is_topic_message === true || threadId !== undefined;
+        return {
+            messageId: msg.message_id.toString(),
+            channel: 'telegram',
+            userId: from.id.toString(),
+            userName: from.first_name + (from.last_name ? ` ${from.last_name}` : ''),
+            chatId: chat.id.toString(),
+            text: overrideText ?? msg.text ?? '',
+            timestamp: new Date(msg.date * 1000),
+            replyTo: msg.reply_to_message?.message_id.toString(),
+            threadId,
+            isForumTopic,
+            raw: ctx,
+        };
+    }
+    async handleIncomingMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(message);
+            }
+            catch (error) {
+                console.error('Error in message handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageHandler');
+            }
+        }
+    }
+    handleError(error, context) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, context);
+            }
+            catch (e) {
+                console.error('Error in error handler:', e);
+            }
+        }
+    }
+    setStatus(status, error) {
+        this._status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, error);
+            }
+            catch (e) {
+                console.error('Error in status handler:', e);
+            }
+        }
+    }
+}
+exports.TelegramAdapter = TelegramAdapter;
+/**
+ * Create a Telegram adapter from configuration
+ */
+function createTelegramAdapter(config) {
+    if (!config.botToken) {
+        throw new Error('Telegram bot token is required');
+    }
+    return new TelegramAdapter(config);
+}