@codebam/cf-workers-telegram-bot 11.18.0 → 12.0.0

package/dist/telegram_api.d.ts

@@ -1,6 +1,7 @@
 import { InlineQueryResult as TelegramInlineQueryResult } from '@grammyjs/types';
 /** Interface for common Telegram API parameters */
 export interface TelegramApiBaseParams {
+    [key: string]: unknown;
     chat_id: number | string;
     message_thread_id?: number;
     business_connection_id?: string | number;
@@ -95,7 +96,19 @@ export interface SendVoiceParams extends TelegramApiBaseParams {
 }
 /** Type for all possible API parameters */
 export type TelegramApiParams = SendMessageParams | SendPhotoParams | SendVideoParams | SendVoiceParams | SendChatActionParams | AnswerCallbackParams | AnswerInlineParams | AnswerGuestParams | SendInvoiceParams | AnswerPreCheckoutParams | Record<string, unknown>;
-/** Class representing the Telegram API and all its methods */
+/** Interface for edit message text parameters */
+export interface EditMessageTextParams extends Partial<TelegramApiBaseParams> {
+    [key: string]: unknown;
+    chat_id?: number | string;
+    message_id?: number;
+    inline_message_id?: string;
+    text: string;
+    parse_mode?: string;
+    disable_web_page_preview?: boolean;
+    reply_markup?: object;
+    business_connection_id?: string | number;
+}
+/** Class representing the telegram API and all its methods */
 export default class TelegramApi {
     /**
      * Get the API URL for a given bot API and slug
@@ -104,7 +117,7 @@ export default class TelegramApi {
      * @param data - data to append to the request
      * @returns Request object with the full URL and parameters
      */
-    getApiUrl(botApi: string, slug: string, data: TelegramApiParams): Request;
+    getApiUrl(botApi: string, slug: string, data: TelegramApiParams, method?: 'GET' | 'POST'): Request;
     /**
      * Fetch a URL and log the response
      * @param url - the URL to fetch
@@ -195,16 +208,7 @@ export default class TelegramApi {
      * @param data - data to append to the request
      * @returns Promise with the API response
      */
-    editMessageText(botApi: string, data: {
-        chat_id?: number | string;
-        message_id?: number;
-        inline_message_id?: string;
-        text: string;
-        parse_mode?: string;
-        disable_web_page_preview?: boolean;
-        reply_markup?: object;
-        business_connection_id?: string | number;
-    }): Promise<Response>;
+    editMessageText(botApi: string, data: EditMessageTextParams): Promise<Response>;
     sendMessageDraft(botApi: string, data: SendMessageDraftParams): Promise<Response>;
     /**
      * Send an invoice to a user
@@ -220,6 +224,13 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     answerPreCheckoutQuery(botApi: string, data: AnswerPreCheckoutParams): Promise<Response>;
+    /**
+     * Get information about a business connection
+     * @param botApi - full URL to the telegram API without slug
+     * @param business_connection_id - unique identifier of the business connection
+     * @returns Promise with the API response
+     */
+    getBusinessConnection(botApi: string, business_connection_id: string): Promise<Response>;
     /**
      * Get basic information about the bot
      * @param botApi - full URL to the telegram API without slug

package/dist/telegram_api.js

@@ -1,4 +1,4 @@
-/** Class representing the Telegram API and all its methods */
+/** Class representing the telegram API and all its methods */
 export default class TelegramApi {
     /**
      * Get the API URL for a given bot API and slug
@@ -7,15 +7,24 @@ export default class TelegramApi {
      * @param data - data to append to the request
      * @returns Request object with the full URL and parameters
      */
-    getApiUrl(botApi, slug, data) {
-        const request = new URL(botApi + (slug.startsWith('/') || botApi.endsWith('/') ? '' : '/') + slug);
-        const params = new URLSearchParams();
-        for (const [key, value] of Object.entries(data)) {
-            if (value !== undefined) {
-                params.append(key, typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value));
+    getApiUrl(botApi, slug, data, method = 'GET') {
+        const baseUrl = botApi + (slug.startsWith('/') || botApi.endsWith('/') ? '' : '/') + slug;
+        if (method === 'GET') {
+            const url = new URL(baseUrl);
+            for (const [key, value] of Object.entries(data)) {
+                if (value !== undefined) {
+                    url.searchParams.append(key, typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value));
+                }
             }
+            return new Request(url.toString());
         }
-        return new Request(`${request.toString()}?${params.toString()}`);
+        return new Request(baseUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
     }
     /**
      * Fetch a URL and log the response
@@ -31,12 +40,20 @@ export default class TelegramApi {
             let errorDescription = '';
             try {
                 const json = (await cloned.json());
-                errorDescription = json.description ? `: ${json.description}` : '';
+                errorDescription = json.description || '';
             }
             catch {
                 // ignore
             }
-            throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}${errorDescription}`);
+            if (errorDescription.includes('BUSINESS_CONNECTION_INVALID') || errorDescription.includes('BUSINESS_PEER_INVALID')) {
+                console.warn(`Telegram API business error: ${errorDescription}`);
+                throw new Error('BUSINESS_CONNECTION_INVALID');
+            }
+            if (errorDescription.includes('PEER_ID_INVALID')) {
+                console.warn(`Telegram API peer error: ${errorDescription}`);
+                throw new Error('PEER_ID_INVALID');
+            }
+            throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}${errorDescription ? ': ' + errorDescription : ''}`);
         }
         const cloned = response.clone();
         try {
@@ -59,7 +76,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendChatAction(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendChatAction', data);
+        const url = this.getApiUrl(botApi, 'sendChatAction', data, 'POST');
         return await this.fetchAndLog(url, 'sendChatAction', data);
     }
     /**
@@ -73,7 +90,7 @@ export default class TelegramApi {
         if (!data.file_id || data.file_id === '') {
             throw new Error('No file_id provided');
         }
-        const url = this.getApiUrl(botApi, 'getFile', data);
+        const url = this.getApiUrl(botApi, 'getFile', data, 'POST');
         const response = await this.fetchAndLog(url, 'getFile', data);
         const json = await response.json();
         if (!json.ok || !json.result?.file_path) {
@@ -92,7 +109,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendMessage(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendMessage', data);
+        const url = this.getApiUrl(botApi, 'sendMessage', data, 'POST');
         return await this.fetchAndLog(url, 'sendMessage', data);
     }
     /**
@@ -102,7 +119,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendVideo(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendVideo', data);
+        const url = this.getApiUrl(botApi, 'sendVideo', data, 'POST');
         return await this.fetchAndLog(url, 'sendVideo', data);
     }
     /**
@@ -112,7 +129,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendPhoto(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendPhoto', data);
+        const url = this.getApiUrl(botApi, 'sendPhoto', data, 'POST');
         return await this.fetchAndLog(url, 'sendPhoto', data);
     }
     /**
@@ -122,7 +139,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendVoice(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendVoice', data);
+        const url = this.getApiUrl(botApi, 'sendVoice', data, 'POST');
         return await this.fetchAndLog(url, 'sendVoice', data);
     }
     /**
@@ -139,7 +156,7 @@ export default class TelegramApi {
             is_personal: data.is_personal,
             next_offset: data.next_offset,
         };
-        const url = this.getApiUrl(botApi, 'answerInlineQuery', params);
+        const url = this.getApiUrl(botApi, 'answerInlineQuery', params, 'POST');
         return await this.fetchAndLog(url, 'answerInlineQuery', params);
     }
     /**
@@ -149,7 +166,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async answerCallback(botApi, data) {
-        const url = this.getApiUrl(botApi, 'answerCallbackQuery', data);
+        const url = this.getApiUrl(botApi, 'answerCallbackQuery', data, 'POST');
         return await this.fetchAndLog(url, 'answerCallbackQuery', data);
     }
     /**
@@ -159,7 +176,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async answerGuestQuery(botApi, data) {
-        const url = this.getApiUrl(botApi, 'answerGuestQuery', data);
+        const url = this.getApiUrl(botApi, 'answerGuestQuery', data, 'POST');
         return await this.fetchAndLog(url, 'answerGuestQuery', data);
     }
     /**
@@ -169,7 +186,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async deleteMessage(botApi, data) {
-        const url = this.getApiUrl(botApi, 'deleteMessage', data);
+        const url = this.getApiUrl(botApi, 'deleteMessage', data, 'POST');
         return await this.fetchAndLog(url, 'deleteMessage', data);
     }
     /**
@@ -179,11 +196,11 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async editMessageText(botApi, data) {
-        const url = this.getApiUrl(botApi, 'editMessageText', data);
+        const url = this.getApiUrl(botApi, 'editMessageText', data, 'POST');
         return await this.fetchAndLog(url, 'editMessageText', data);
     }
     async sendMessageDraft(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendMessageDraft', data);
+        const url = this.getApiUrl(botApi, 'sendMessageDraft', data, 'POST');
         return await this.fetchAndLog(url, 'sendMessageDraft', data);
     }
     /**
@@ -193,7 +210,7 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async sendInvoice(botApi, data) {
-        const url = this.getApiUrl(botApi, 'sendInvoice', data);
+        const url = this.getApiUrl(botApi, 'sendInvoice', data, 'POST');
         return await this.fetchAndLog(url, 'sendInvoice', data);
     }
     /**
@@ -203,16 +220,26 @@ export default class TelegramApi {
      * @returns Promise with the API response
      */
     async answerPreCheckoutQuery(botApi, data) {
-        const url = this.getApiUrl(botApi, 'answerPreCheckoutQuery', data);
+        const url = this.getApiUrl(botApi, 'answerPreCheckoutQuery', data, 'POST');
         return await this.fetchAndLog(url, 'answerPreCheckoutQuery', data);
     }
+    /**
+     * Get information about a business connection
+     * @param botApi - full URL to the telegram API without slug
+     * @param business_connection_id - unique identifier of the business connection
+     * @returns Promise with the API response
+     */
+    async getBusinessConnection(botApi, business_connection_id) {
+        const url = this.getApiUrl(botApi, 'getBusinessConnection', { business_connection_id }, 'POST');
+        return await this.fetchAndLog(url, 'getBusinessConnection', { business_connection_id });
+    }
     /**
      * Get basic information about the bot
      * @param botApi - full URL to the telegram API without slug
      * @returns Promise with the API response
      */
     async getMe(botApi) {
-        const url = this.getApiUrl(botApi, 'getMe', {});
+        const url = this.getApiUrl(botApi, 'getMe', {}, 'GET');
         return await this.fetchAndLog(url, 'getMe', {});
     }
 }

package/dist/telegram_bot.js

@@ -160,6 +160,10 @@ export default class TelegramBot {
                     console.log(this.update);
                     const ctx = new TelegramExecutionContext(this, this.update);
                     this.currentContext = ctx;
+                    if (!(await ctx.shouldProcess())) {
+                        console.log('Skipping update processing based on context validation');
+                        return new Response('ok');
+                    }
                     // Run middleware
                     for (const middleware of this.middleware) {
                         const result = await middleware(ctx);

package/dist/telegram_execution_context.d.ts

@@ -3,6 +3,10 @@ import TelegramApi from './telegram_api.js';
 import TelegramBot from './telegram_bot.js';
 /** Class representing the context of execution */
 export default class TelegramExecutionContext {
+    /** Cache for business connection owners */
+    private static businessOwners;
+    /** Cache for dead business connections */
+    private static poisonedConnections;
     /** an instance of the telegram bot */
     bot: TelegramBot;
     /** an instance of the telegram update */
@@ -43,6 +47,11 @@ export default class TelegramExecutionContext {
      * Determine the type of update received
      * @returns The update type as a string
      */
+    /**
+     * Determine if the current update should be processed.
+     * For business messages, this checks if the connection is valid and has reply permissions.
+     */
+    shouldProcess(): Promise<boolean>;
     private determineUpdateType;
     /**
      * Get the chat ID from the current update
@@ -65,6 +74,10 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendVideo
      * @returns Promise with the API response
      */
+    /**
+     * Helper to handle business connection fallbacks
+     */
+    private withBusinessFallback;
     replyVideo(video: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
     /**
      * Get File from telegram file_id
@@ -148,14 +161,7 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendMessage/editMessageText
      * @returns Promise with the API response
      */
-    streamReply(message: string, draft_id: number, parse_mode?: string, options?: Record<string, number | string | boolean | object>): Promise<Response>;
-    /**
-     * Reply to the last message with text
-     * @param message - text to reply with
-     * @param parse_mode - one of HTML, MarkdownV2, Markdown, or an empty string for ascii
-     * @param options - any additional options to pass to sendMessage
-     * @returns Promise with the API response
-     */
+    streamReply(message: string, draft_id: number, parse_mode?: string, options?: Record<string, number | string | boolean | object>, finish?: boolean): Promise<Response | null>;
     reply(message: string, parse_mode?: string, reply?: boolean, options?: Record<string, number | string | boolean>): Promise<Response | null>;
     /**
      * Send an invoice for Telegram Stars
@@ -165,7 +171,7 @@ export default class TelegramExecutionContext {
      * @param amount - amount of stars
      * @returns Promise with the API response
      */
-    sendStarsInvoice(title: string, description: string, payload: string, amount: number): Promise<Response>;
+    sendStarsInvoice(title: string, description: string, payload: string, amount: number): Promise<Response | null>;
     /**
      * Answer a pre-checkout query
      * @param ok - whether the payment can proceed

package/dist/telegram_execution_context.js

@@ -1,6 +1,10 @@
 import TelegramApi from './telegram_api.js';
 /** Class representing the context of execution */
 export default class TelegramExecutionContext {
+    /** Cache for business connection owners */
+    static businessOwners = new Map();
+    /** Cache for dead business connections */
+    static poisonedConnections = new Set();
     /** an instance of the telegram bot */
     bot;
     /** an instance of the telegram update */
@@ -63,6 +67,54 @@ export default class TelegramExecutionContext {
      * Determine the type of update received
      * @returns The update type as a string
      */
+    /**
+     * Determine if the current update should be processed.
+     * For business messages, this checks if the connection is valid and has reply permissions.
+     */
+    async shouldProcess() {
+        if (this.update_type !== 'business_message') {
+            return true;
+        }
+        const connectionId = this.update.business_message?.business_connection_id?.toString();
+        if (!connectionId) {
+            return true;
+        }
+        if (TelegramExecutionContext.poisonedConnections.has(connectionId)) {
+            return false;
+        }
+        let ownerId = TelegramExecutionContext.businessOwners.get(connectionId);
+        if (ownerId === undefined) {
+            try {
+                const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
+                if (response.status === 200) {
+                    const json = await response.json();
+                    if (json.ok && json.result) {
+                        ownerId = json.result.user?.id || json.result.user_chat_id;
+                        if (ownerId) {
+                            TelegramExecutionContext.businessOwners.set(connectionId, ownerId);
+                        }
+                        if (json.result.can_reply === false) {
+                            console.warn('Business connection ' + connectionId + ' lacks reply permissions, poisoning connection');
+                            TelegramExecutionContext.poisonedConnections.add(connectionId);
+                            return false;
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                if (e instanceof Error && e.message === 'BUSINESS_CONNECTION_INVALID') {
+                    console.warn('Business connection ' + connectionId + ' is invalid, poisoning connection');
+                    TelegramExecutionContext.poisonedConnections.add(connectionId);
+                    return false;
+                }
+                console.warn('Failed to fetch business connection info:', e);
+            }
+        }
+        if (ownerId !== undefined && this.getChatId() === ownerId.toString()) {
+            return false;
+        }
+        return true;
+    }
     determineUpdateType() {
         if (this.update.message?.photo) {
             return 'photo';
@@ -123,6 +175,9 @@ export default class TelegramExecutionContext {
         if (this.update.message?.message_id) {
             return this.update.message.message_id.toString();
         }
+        else if (this.update.business_message?.message_id) {
+            return this.update.business_message.message_id.toString();
+        }
         else if (this.update.guest_message?.message_id) {
             return this.update.guest_message.message_id.toString();
         }
@@ -133,7 +188,7 @@ export default class TelegramExecutionContext {
      * @returns The message thread ID as a number or undefined
      */
     getThreadId() {
-        return this.update.message?.message_thread_id;
+        return this.update.message?.message_thread_id ?? this.update.business_message?.message_thread_id;
     }
     /**
      * Reply to the last message with a video
@@ -141,36 +196,85 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendVideo
      * @returns Promise with the API response
      */
-    async replyVideo(video, options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-                return await this.api.sendVideo(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    video,
-                });
-            case 'business_message':
-                return await this.api.sendVideo(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id?.toString() ?? '',
-                    video,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryVideo(video);
-            case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    ...options,
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [{ type: 'video', id: crypto.randomUUID(), video_url: video, mime_type: 'video/mp4', thumbnail_url: video, title: 'Video' }],
-                });
-            default:
+    /**
+     * Helper to handle business connection fallbacks
+     */
+    async withBusinessFallback(params, apiMethod) {
+        const connectionId = params.business_connection_id?.toString();
+        if (connectionId) {
+            if (TelegramExecutionContext.poisonedConnections.has(connectionId)) {
+                return null;
+            }
+            let ownerId = TelegramExecutionContext.businessOwners.get(connectionId);
+            if (ownerId === undefined) {
+                try {
+                    const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
+                    if (response.status === 200) {
+                        const json = await response.json();
+                        if (json.ok && json.result) {
+                            ownerId = json.result.user?.id || json.result.user_chat_id;
+                            if (ownerId) {
+                                TelegramExecutionContext.businessOwners.set(connectionId, ownerId);
+                            }
+                            if (json.result.can_reply === false) {
+                                TelegramExecutionContext.poisonedConnections.add(connectionId);
+                                return null;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message === 'BUSINESS_CONNECTION_INVALID') {
+                        TelegramExecutionContext.poisonedConnections.add(connectionId);
+                        return null;
+                    }
+                }
+            }
+            if (ownerId !== undefined && params.chat_id?.toString() === ownerId.toString()) {
                 return null;
+            }
+        }
+        try {
+            return await apiMethod(this.bot.api.toString(), params);
         }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.message === 'BUSINESS_CONNECTION_INVALID') {
+                    if (connectionId) {
+                        TelegramExecutionContext.poisonedConnections.add(connectionId);
+                    }
+                    return null;
+                }
+                if (e.message === 'PEER_ID_INVALID') {
+                    return null;
+                }
+            }
+            throw e;
+        }
+    }
+    async replyVideo(video, options = {}) {
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            video,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendVideo(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryVideo(video);
+        }
+        if (this.update_type === 'inline') {
+            return await this.api.answerInline(this.bot.api.toString(), {
+                ...options,
+                inline_query_id: this.update.inline_query?.id.toString() ?? '',
+                results: [{ type: 'video', id: crypto.randomUUID(), video_url: video, mime_type: 'video/mp4', thumbnail_url: video, title: 'Video' }],
+            });
+        }
+        return await this.api.sendVideo(this.bot.api.toString(), params);
     }
     /**
      * Get File from telegram file_id
@@ -188,37 +292,28 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async replyPhoto(photo, caption = '', options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'photo':
-            case 'message':
-                return await this.api.sendPhoto(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    photo,
-                    caption,
-                });
-            case 'business_message':
-                return await this.api.sendPhoto(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id?.toString() ?? '',
-                    photo,
-                    caption,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryPhoto(photo, caption);
-            case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [{ type: 'photo', id: crypto.randomUUID(), photo_url: photo, thumbnail_url: photo }],
-                });
-            default:
-                return null;
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            photo,
+            caption,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendPhoto(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryPhoto(photo, caption);
         }
+        if (this.update_type === 'inline') {
+            return await this.api.answerInline(this.bot.api.toString(), {
+                inline_query_id: this.update.inline_query?.id.toString() ?? '',
+                results: [{ type: 'photo', id: crypto.randomUUID(), photo_url: photo, thumbnail_url: photo }],
+            });
+        }
+        return await this.api.sendPhoto(this.bot.api.toString(), params);
     }
     /**
      * Reply to the last message with a voice message
@@ -228,57 +323,38 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async replyVoice(voice, caption = '', options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-                return await this.api.sendVoice(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    voice,
-                    caption,
-                });
-            case 'business_message':
-                return await this.api.sendVoice(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id?.toString() ?? '',
-                    voice,
-                    caption,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryVoice(voice, caption);
-            default:
-                return null;
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            voice,
+            caption,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendVoice(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryVoice(voice, caption);
         }
+        return await this.api.sendVoice(this.bot.api.toString(), params);
     }
     /**
      * Send typing in a chat
      * @returns Promise with the API response
      */
     async sendTyping() {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-            case 'photo':
-            case 'document':
-                return await this.api.sendChatAction(this.bot.api.toString(), {
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    action: 'typing',
-                });
-            case 'business_message':
-                return await this.api.sendChatAction(this.bot.api.toString(), {
-                    business_connection_id: this.update.business_message?.business_connection_id?.toString() ?? '',
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    action: 'typing',
-                });
-            default:
-                return null;
+        const params = {
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            action: 'typing',
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendChatAction(api, data));
         }
+        return await this.api.sendChatAction(this.bot.api.toString(), params);
     }
     /**
      * Reply to an inline message with a title and content
@@ -356,104 +432,56 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendMessage/editMessageText
      * @returns Promise with the API response
      */
-    async streamReply(message, draft_id, parse_mode = '', options = {}) {
-        const message_id = this.drafts.get(draft_id);
-        const business_connection_id = this.update.business_message?.business_connection_id?.toString();
-        if (message_id) {
-            return await this.api.editMessageText(this.bot.api.toString(), {
-                chat_id: this.getChatId(),
-                message_id,
-                text: message,
-                parse_mode,
-                business_connection_id,
-                ...options,
-            });
-        }
+    async streamReply(message, draft_id, parse_mode = '', options = {}, finish = false) {
         if (this.update_type === 'guest_message') {
-            if (this.drafts.has(draft_id)) {
-                return new Response('Query already answered', { status: 200 });
+            if (finish) {
+                return await this.answerGuestQueryText(message, parse_mode);
             }
-            this.drafts.set(draft_id, -1);
-            return await this.answerGuestQueryText(message, parse_mode);
+            return null;
+        }
+        if (finish) {
+            return await this.reply(message, parse_mode, true, options);
         }
-        const response = await this.api.sendMessage(this.bot.api.toString(), {
+        const params = {
             ...options,
             chat_id: this.getChatId(),
             message_thread_id: this.getThreadId(),
             text: message,
             parse_mode,
-            business_connection_id,
-        });
-        if (response.status === 200) {
-            const cloned = response.clone();
-            try {
-                const json = (await cloned.json());
-                if (json.ok && json.result?.message_id) {
-                    this.drafts.set(draft_id, json.result.message_id);
-                }
-            }
-            catch {
-                // ignore
-            }
+            draft_id,
+        };
+        if (this.update_type === 'business_message') {
+            params.business_connection_id = this.update.business_message?.business_connection_id;
         }
-        return response;
+        return await this.withBusinessFallback(params, (api, data) => this.api.sendMessageDraft(api, data));
     }
-    /**
-     * Reply to the last message with text
-     * @param message - text to reply with
-     * @param parse_mode - one of HTML, MarkdownV2, Markdown, or an empty string for ascii
-     * @param options - any additional options to pass to sendMessage
-     * @returns Promise with the API response
-     */
     async reply(message, parse_mode = '', reply = true, options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-            case 'photo':
-            case 'document':
-                if (reply) {
-                    return await this.api.sendMessage(this.bot.api.toString(), {
-                        ...options,
-                        chat_id: this.getChatId(),
-                        message_thread_id: this.getThreadId(),
-                        reply_to_message_id: this.getMessageId(),
-                        text: message,
-                        parse_mode,
-                    });
-                }
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    text: message,
-                    parse_mode,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryText(message, parse_mode);
-            case 'business_message':
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    text: message,
-                    business_connection_id: this.update.business_message?.business_connection_id?.toString() ?? '',
-                    parse_mode,
-                });
-            case 'callback':
-                if (this.update.callback_query?.message?.chat.id) {
-                    return await this.api.sendMessage(this.bot.api.toString(), {
-                        ...options,
-                        chat_id: this.update.callback_query.message.chat.id.toString(),
-                        message_thread_id: this.getThreadId(),
-                        text: message,
-                        parse_mode,
-                    });
-                }
-                return null;
-            case 'inline':
-                return await this.replyInline('Response', message, parse_mode);
-            default:
-                return null;
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryText(message, parse_mode);
+        }
+        if (this.update_type === 'inline') {
+            return await this.replyInline('Response', message, parse_mode);
         }
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            text: message,
+            parse_mode,
+        };
+        if (reply) {
+            params.reply_to_message_id = this.getMessageId();
+        }
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendMessage(api, data));
+        }
+        if (this.update_type === 'callback') {
+            if (this.update.callback_query?.message?.chat.id) {
+                params['chat_id'] = this.update.callback_query.message.chat.id.toString();
+            }
+        }
+        return await this.api.sendMessage(this.bot.api.toString(), params);
     }
     /**
      * Send an invoice for Telegram Stars
@@ -464,17 +492,21 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async sendStarsInvoice(title, description, payload, amount) {
-        return await this.api.sendInvoice(this.bot.api.toString(), {
+        const params = {
             chat_id: this.getChatId(),
             message_thread_id: this.getThreadId(),
-            business_connection_id: this.update.business_message?.business_connection_id?.toString(),
             title,
             description,
             payload,
             provider_token: '',
             currency: 'XTR',
             prices: [{ label: title, amount }],
-        });
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendInvoice(api, data));
+        }
+        return await this.api.sendInvoice(this.bot.api.toString(), params);
     }
     /**
      * Answer a pre-checkout query

package/dist/utils.js

@@ -27,16 +27,17 @@ export async function markdownToHtml(s) {
         return result;
     };
     renderer.listitem = (item) => {
-        return renderer.parser.parseInline(item.tokens);
+        return renderer.parser.parse(item.tokens).trim();
     };
     renderer.strong = ({ tokens }) => `<b>${renderer.parser.parseInline(tokens)}</b>`;
     renderer.em = ({ tokens }) => `<i>${renderer.parser.parseInline(tokens)}</i>`;
     renderer.codespan = ({ text }) => `<code>${text}</code>`;
     renderer.code = ({ text, lang }) => {
+        const escapedText = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
         if (lang) {
-            return `<pre><code class="language-${lang}">${text}</code></pre>\n`;
+            return `<pre><code class="language-${lang}">${escapedText}</code></pre>\n`;
         }
-        return `<pre><code>${text}</code></pre>\n`;
+        return `<pre><code>${escapedText}</code></pre>\n`;
     };
     renderer.del = ({ tokens }) => `<s>${renderer.parser.parseInline(tokens)}</s>`;
     renderer.link = ({ href, tokens }) => `<a href="${href}">${renderer.parser.parseInline(tokens)}</a>`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codebam/cf-workers-telegram-bot",
-	"version": "11.18.0",
+	"version": "12.0.0",
 	"description": "serverless telegram bot on cf workers",
 	"main": "./dist/main.js",
 	"module": "./dist/main.js",
@@ -32,7 +32,7 @@
 	"license": "Apache-2.0",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/codebam/cf-workers-telegram-bot.git"
+		"url": "git+https://github.com/codebam/cf-workers-telegram-bot.git"
 	},
 	"devDependencies": {
 		"@cloudflare/workers-types": "^4.20260511.1",