@codebam/cf-workers-telegram-bot 12.6.2 → 12.6.5

package/README.md

@@ -119,6 +119,50 @@ npx wrangler deploy
 
 To automate deployments, use the [Wrangler Action](https://github.com/cloudflare/wrangler-action) or Cloudflare's built-in [GitHub integration](https://developers.cloudflare.com/workers/ci-cd/github-actions/).
 
+## Structure
+
+This is a monorepo containing:
+- Root: Core library `@codebam/cf-workers-telegram-bot`
+- `ai-workflow`: A Cloudflare Workflow for handling long-running AI tasks
+- `webapp`: A Svelte 5 web application for interacting with the bot
+- `consumer`: A minimal consumer of the library
+
+## Development
+
+You can use the root `Makefile` to run common tasks across all projects:
+
+```sh
+make build   # Build all projects
+make test    # Run tests for all projects
+make lint    # Lint all projects
+make format  # Format all projects
+```
+
+### Setup
+
+1. **Install dependencies**:
+   ```sh
+   npm install
+   ```
+
+2. **Set up Git hooks**:
+   This project uses custom Git hooks for quality control. Run the following script to enable them:
+   ```sh
+   ./setup_hooks.sh
+   ```
+
+### Scripts
+
+- `npm run lint`: Run ESLint on the source code.
+- `npm run format`: Format the code using Prettier.
+- `npm run build`: Compile TypeScript and run type checks.
+- `npm run test`: Run unit tests with Vitest.
+- `npm run lint:all`: Run linting for the root project and all subprojects.
+- `npm run build:all`: Run build for the root project and all subprojects.
+- `npm run test:all`: Run tests for the root project and all subprojects.
+
+The pre-commit hook automatically runs formatting and linting on staged files (via `lint-staged`), followed by a full project type check and tests before every commit.
+
 ## API Documentation
 
 Detailed API documentation is available at [cf-workers-telegram-bot.codebam.ca](https://cf-workers-telegram-bot.codebam.ca).

package/dist/ai.d.ts

@@ -0,0 +1,23 @@
+import TelegramExecutionContext from './telegram_execution_context';
+/**
+ * Robustly extract text from various AI response formats.
+ * Handles OpenAI, Cloudflare, and Google Gemini structures.
+ */
+export declare function extractText(obj: any): string;
+/**
+ * Custom runner that supports tool calls across different AI models.
+ */
+export declare function customRunWithTools(ai: any, model: string, input: {
+    messages: any[];
+    tools?: any[];
+}, config: {
+    streamFinalResponse: boolean;
+}): Promise<any>;
+/**
+ * Stream AI response to Telegram, with periodic updates to avoid rate limits.
+ */
+export declare function streamAiResponseToTelegram(bot: TelegramExecutionContext, ai: any, modelId: string, messages: any[], task: any, tools?: any[]): Promise<string>;
+/**
+ * Creates a mock TelegramExecutionContext for use in environments where the full context isn't available (e.g., Workflows).
+ */
+export declare function createMockTelegramExecutionContext(task: Record<string, unknown>): TelegramExecutionContext;

package/dist/ai.js

@@ -0,0 +1,367 @@
+import TelegramApi from './telegram_api';
+import { markdownToHtml } from './utils';
+/**
+ * Robustly extract text from various AI response formats.
+ * Handles OpenAI, Cloudflare, and Google Gemini structures.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractText(obj) {
+    if (typeof obj === 'string') {
+        return obj;
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        return '';
+    }
+    // Direct fields
+    if (typeof obj.response === 'string') {
+        return obj.response;
+    }
+    if (typeof obj.text === 'string') {
+        return obj.text;
+    }
+    if (typeof obj.content === 'string') {
+        return obj.content;
+    }
+    if (typeof obj.delta === 'string') {
+        return obj.delta;
+    }
+    // Nested fields
+    if (obj.choices && Array.isArray(obj.choices) && obj.choices.length > 0) {
+        return extractText(obj.choices[0]);
+    }
+    if (obj.message) {
+        return extractText(obj.message);
+    }
+    if (obj.delta) {
+        return extractText(obj.delta);
+    }
+    if (obj.candidates && Array.isArray(obj.candidates) && obj.candidates.length > 0) {
+        return extractText(obj.candidates[0]);
+    }
+    if (obj.content) {
+        return extractText(obj.content);
+    }
+    if (obj.parts && Array.isArray(obj.parts) && obj.parts.length > 0) {
+        return extractText(obj.parts[0]);
+    }
+    return '';
+}
+/**
+ * Custom runner that supports tool calls across different AI models.
+ */
+export async function customRunWithTools(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ai, model, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input, config) {
+    const messages = [...input.messages];
+    const tools = input.tools || [];
+    const isGemini = model.includes('google/gemini');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cfTools = tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const runModel = async (msgs, stream) => {
+        if (isGemini) {
+            const systemMessage = msgs.find((m) => m.role === 'system');
+            const otherMessages = msgs.filter((m) => m.role !== 'system');
+            const geminiInput = {
+                contents: otherMessages.map((m) => ({
+                    role: m.role === 'assistant' ? 'model' : 'user',
+                    parts: [{ text: m.content }],
+                })),
+                stream,
+            };
+            if (systemMessage) {
+                geminiInput.system_instruction = {
+                    parts: [{ text: systemMessage.content }],
+                };
+            }
+            return await ai.run(model, geminiInput);
+        }
+        return await ai.run(model, { messages: msgs, tools: cfTools.length > 0 ? cfTools : undefined, stream });
+    };
+    if (cfTools.length === 0 || isGemini) {
+        return await runModel(messages, config.streamFinalResponse);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response = (await runModel(messages, false));
+    // FIX: Robustly extract from BOTH Cloudflare formats (Standard and OpenAI-compatible)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let toolCalls = [];
+    if (response?.tool_calls) {
+        toolCalls = [...response.tool_calls];
+    }
+    else if (response?.choices?.[0]?.message?.tool_calls) {
+        toolCalls = [...response.choices[0].message.tool_calls];
+    }
+    let responseText = response?.response || response?.choices?.[0]?.message?.content || '';
+    // GEMMA/LLAMA FALLBACK: Catch raw tokens if native interception fails
+    if (toolCalls.length === 0) {
+        const gemmaRegex = /<\|tool_call>\s*call:\s*([a-zA-Z0-9_]+)([\s\S]*?)<tool_call\|>/g;
+        const standardRegex = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+        let match;
+        while ((match = gemmaRegex.exec(responseText)) !== null) {
+            let name = match[1].trim();
+            if (name === 'http_fetch' || name === 'api_fetch') {
+                name = 'fetch';
+            }
+            let argsString = match[2].trim();
+            // Sanitize malformed JSON syntax
+            argsString = argsString.replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":').replace(/:\s*'([^']*)'/g, ': "$1"');
+            toolCalls.push({
+                id: `call_${Math.random().toString(36).substring(2, 9)}`,
+                type: 'function',
+                function: { name, arguments: argsString },
+            });
+        }
+        while ((match = standardRegex.exec(responseText)) !== null) {
+            const content = match[1].trim();
+            try {
+                // Handle both raw JSON and name/args format
+                const parsed = JSON.parse(content.replace(/'/g, '"'));
+                const name = parsed.name || 'fetch';
+                const args = parsed.arguments || parsed;
+                toolCalls.push({
+                    id: `call_${Math.random().toString(36).substring(2, 9)}`,
+                    type: 'function',
+                    function: { name, arguments: typeof args === 'string' ? args : JSON.stringify(args) },
+                });
+            }
+            catch (e) {
+                console.error('Failed to parse tool call:', content, e);
+            }
+        }
+        // Strip the raw tokens from the visible response
+        responseText = responseText
+            .replace(/<\|tool_call>[\s\S]*?<tool_call\|>/g, '')
+            .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '')
+            .trim();
+    }
+    if (toolCalls.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const normalizedToolCalls = toolCalls.map((call, index) => {
+            const name = call.name || (call.function && call.function.name);
+            let args = call.arguments || (call.function && call.function.arguments);
+            if (typeof args !== 'string') {
+                try {
+                    args = JSON.stringify(args);
+                }
+                catch {
+                    args = '{}';
+                }
+            }
+            return {
+                id: call.id || `call_${Math.random().toString(36).substring(2, 9)}_${index}`,
+                type: 'function',
+                function: { name, arguments: args },
+            };
+        });
+        messages.push({
+            role: 'assistant',
+            content: responseText,
+            tool_calls: normalizedToolCalls,
+        });
+        for (const call of normalizedToolCalls) {
+            const toolName = call.function.name;
+            const toolId = call.id;
+            const toolArgsString = call.function.arguments;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tool = tools.find((t) => t.name === toolName);
+            if (tool && tool.function) {
+                try {
+                    let parsedArgs;
+                    try {
+                        parsedArgs = JSON.parse(toolArgsString);
+                    }
+                    catch {
+                        parsedArgs = toolArgsString;
+                    }
+                    const result = await tool.function(parsedArgs);
+                    messages.push({ role: 'tool', tool_call_id: toolId, name: toolName, content: String(result) });
+                }
+                catch (e) {
+                    messages.push({ role: 'tool', tool_call_id: toolId, name: toolName, content: String(e) });
+                }
+            }
+            else {
+                messages.push({ role: 'tool', tool_call_id: toolId, name: toolName, content: 'Tool not found' });
+            }
+        }
+        return await runModel(messages, true);
+    }
+    return response;
+}
+/**
+ * Stream AI response to Telegram, with periodic updates to avoid rate limits.
+ */
+export async function streamAiResponseToTelegram(bot, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ai, modelId, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+messages, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+task, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tools = []) {
+    const botApi = new TelegramApi();
+    // Use updateId as a stable draftId if available, otherwise generate one
+    const draftId = task.updateId || Date.now();
+    // Skip Thinking message for guest messages as they only support one response
+    if (task.updateType !== 'guest_message') {
+        await botApi.sendMessageDraft(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+            chat_id: task.chatId,
+            text: 'Thinking...',
+            parse_mode: 'HTML',
+            message_thread_id: task.threadId,
+            business_connection_id: task.businessConnectionId,
+            draft_id: draftId,
+        });
+    }
+    let streamContent = '';
+    let lastUpdate = Date.now();
+    try {
+        const aiResponse = await customRunWithTools(ai, modelId, {
+            messages,
+            tools,
+        }, { streamFinalResponse: true });
+        if (typeof aiResponse === 'object' && aiResponse !== null && 'getReader' in aiResponse) {
+            const stream = aiResponse;
+            const reader = stream.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                const chunk = decoder.decode(value, { stream: true });
+                const lines = chunk.split('\n');
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]') {
+                            break;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const text = extractText(parsed);
+                            streamContent += text;
+                        }
+                        catch {
+                            // Ignore malformed JSON chunks
+                        }
+                    }
+                }
+                // Update Telegram every 2 seconds to avoid rate limits
+                if (task.updateType !== 'guest_message' && Date.now() - lastUpdate > 2000 && streamContent.trim()) {
+                    const currentContent = streamContent;
+                    bot
+                        .streamReply(await markdownToHtml(currentContent + '...'), draftId, 'HTML')
+                        .catch((e) => console.error('Streaming error:', e));
+                    lastUpdate = Date.now();
+                }
+            }
+        }
+        else {
+            // Handle static response
+            streamContent = extractText(aiResponse);
+        }
+    }
+    catch (e) {
+        console.error('Error reading AI stream:', e);
+    }
+    // Send final response (blocking)
+    if (streamContent.trim()) {
+        await bot.streamReply(await markdownToHtml(streamContent), draftId, 'HTML', {}, true);
+    }
+    return streamContent;
+}
+/**
+ * Creates a mock TelegramExecutionContext for use in environments where the full context isn't available (e.g., Workflows).
+ */
+export function createMockTelegramExecutionContext(task) {
+    return {
+        chat: { id: task.chatId },
+        from: { id: task.userId },
+        update_type: task.updateType,
+        reply: async (text, options = {}) => {
+            const api = new TelegramApi();
+            if (task.updateType === 'guest_message' && task.guestQueryId) {
+                return await api.answerGuestQuery(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                    guest_query_id: task.guestQueryId,
+                    result: {
+                        type: 'article',
+                        id: crypto.randomUUID(),
+                        title: 'Response',
+                        input_message_content: { message_text: text, parse_mode: (options.parse_mode || 'HTML') },
+                    },
+                });
+            }
+            return await api.sendMessage(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                chat_id: task.chatId,
+                text,
+                parse_mode: (options.parse_mode || 'HTML'),
+                reply_markup: options.reply_markup,
+                message_thread_id: task.threadId,
+                business_connection_id: task.businessConnectionId,
+                reply_to_message_id: task.messageId,
+            });
+        },
+        streamReply: async (text, draft_id, parse_mode = '', options = {}, finish = false) => {
+            const api = new TelegramApi();
+            if (task.updateType === 'guest_message' && task.guestQueryId) {
+                if (finish) {
+                    return await api.answerGuestQuery(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                        guest_query_id: task.guestQueryId,
+                        result: {
+                            type: 'article',
+                            id: crypto.randomUUID(),
+                            title: 'Response',
+                            input_message_content: { message_text: text, parse_mode: (parse_mode || 'HTML') },
+                        },
+                    });
+                }
+                return null;
+            }
+            if (finish) {
+                // Send a final message draft to signal the end of animation
+                await api.sendMessageDraft(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                    chat_id: task.chatId,
+                    text,
+                    parse_mode: (parse_mode || 'HTML'),
+                    draft_id,
+                    message_thread_id: task.threadId,
+                    business_connection_id: task.businessConnectionId,
+                    finish: true,
+                    ...options,
+                });
+                // Then send the actual final message as a reply
+                return await api.sendMessage(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                    chat_id: task.chatId,
+                    text,
+                    parse_mode: (parse_mode || 'HTML'),
+                    reply_markup: options.reply_markup,
+                    message_thread_id: task.threadId,
+                    business_connection_id: task.businessConnectionId,
+                    reply_to_message_id: task.messageId,
+                });
+            }
+            return await api.sendMessageDraft(`https://api.telegram.org/bot${task.telegramToken || task.token}`, {
+                chat_id: task.chatId,
+                text,
+                parse_mode: (parse_mode || 'HTML'),
+                draft_id,
+                message_thread_id: task.threadId,
+                business_connection_id: task.businessConnectionId,
+                finish: false,
+                ...options,
+            });
+        },
+    };
+}

package/dist/history_manager.js

@@ -36,7 +36,7 @@ export class HistoryManager {
         history.push({ role: 'assistant', content: response });
         const trimmedHistory = history.slice(-20);
         await this.kv.put(this.getKey(userId, threadId), JSON.stringify(trimmedHistory), {
-            expirationTtl: 86400
+            expirationTtl: 86400,
         });
     }
     /**

package/dist/main.d.ts

@@ -9,5 +9,6 @@ import PartialTelegramUpdate from './types/PartialTelegramUpdate.js';
 import TelegramInlineQueryType from './types/TelegramInlineQueryType.js';
 import { markdownToHtml, fetchTool } from './utils.js';
 import { HistoryManager, getBalance } from './history_manager.js';
+export { extractText, customRunWithTools, streamAiResponseToTelegram, createMockTelegramExecutionContext } from './ai.js';
 export default TelegramBot;
 export { TelegramBot, TelegramExecutionContext, Webhook, TelegramApi, TelegramApiBaseParams, SendMessageParams, SendMessageDraftParams, SendPhotoParams, SendVideoParams, SendVoiceParams, SendChatActionParams, AnswerCallbackParams, AnswerInlineParams, AnswerGuestParams, SendInvoiceParams, AnswerPreCheckoutParams, TelegramApiParams, TelegramCommand, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramVoice, TelegramGuestMessage, TelegramInputMessageContent, TelegramInlineQuery, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, TelegramInlineQueryResultVideo, TelegramInlineQueryResultVoice, ChatPermissions, TelegramBusinessMessage, TelegramCallbackQuery, TelegramPreCheckoutQuery, TelegramDocument, TelegramSuccessfulPayment, markdownToHtml, fetchTool, HistoryManager, getBalance, };

package/dist/main.js

@@ -4,5 +4,6 @@ import Webhook from './webhook.js';
 import TelegramApi from './telegram_api.js';
 import { markdownToHtml, fetchTool } from './utils.js';
 import { HistoryManager, getBalance } from './history_manager.js';
+export { extractText, customRunWithTools, streamAiResponseToTelegram, createMockTelegramExecutionContext } from './ai.js';
 export default TelegramBot;
 export { TelegramBot, TelegramExecutionContext, Webhook, TelegramApi, markdownToHtml, fetchTool, HistoryManager, getBalance, };

package/dist/telegram_api.d.ts

@@ -9,7 +9,7 @@ export interface TelegramApiBaseParams {
 /** Interface for message parameters */
 export interface SendMessageParams extends TelegramApiBaseParams {
     text: string;
-    parse_mode: string;
+    parse_mode?: string;
     reply_to_message_id?: number | string;
     disable_web_page_preview?: boolean;
     disable_notification?: boolean;

package/dist/telegram_execution_context.d.ts

@@ -1,5 +1,5 @@
 import { Update as TelegramUpdate, InlineQueryResult as TelegramInlineQueryResult } from '@grammyjs/types';
-import TelegramApi from './telegram_api.js';
+import TelegramApi, { SendMessageParams, SendPhotoParams, SendVideoParams, SendVoiceParams, SendMessageDraftParams } from './telegram_api.js';
 import TelegramBot from './telegram_bot.js';
 /** Class representing the context of execution */
 export default class TelegramExecutionContext {
@@ -83,7 +83,7 @@ export default class TelegramExecutionContext {
      * Helper to handle business connection fallbacks
      */
     private withBusinessFallback;
-    replyVideo(video: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
+    replyVideo(video: string, options?: Partial<SendVideoParams>): Promise<Response | null>;
     /**
      * Get File from telegram file_id
      * @param file_id - telegram file_id
@@ -97,7 +97,7 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendPhoto
      * @returns Promise with the API response
      */
-    replyPhoto(photo: string, caption?: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
+    replyPhoto(photo: string, caption?: string, options?: Partial<SendPhotoParams>): Promise<Response | null>;
     /**
      * Reply to the last message with a voice message
      * @param voice - url or file_id to voice
@@ -105,7 +105,7 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendVoice
      * @returns Promise with the API response
      */
-    replyVoice(voice: string, caption?: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
+    replyVoice(voice: string, caption?: string, options?: Partial<SendVoiceParams>): Promise<Response | null>;
     /**
      * Send typing in a chat
      * @returns Promise with the API response
@@ -166,8 +166,8 @@ 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>, finish?: boolean): Promise<Response | null>;
-    reply(message: string, parse_mode?: string, reply?: boolean, options?: Record<string, number | string | boolean>): Promise<Response | null>;
+    streamReply(message: string, draft_id: number, parse_mode?: string, options?: Partial<SendMessageDraftParams>, finish?: boolean): Promise<Response | null>;
+    reply(message: string, parse_mode?: string, reply?: boolean, options?: Partial<SendMessageParams>): Promise<Response | null>;
     /**
      * Send an invoice for Telegram Stars
      * @param title - product name

package/dist/telegram_execution_context.js

@@ -52,10 +52,7 @@ export default class TelegramExecutionContext {
      * @returns True if the sender is a bot
      */
     get isBot() {
-        return (this.update.message?.from?.is_bot ??
-            this.update.business_message?.from?.is_bot ??
-            this.update.guest_message?.from?.is_bot ??
-            false);
+        return (this.update.message?.from?.is_bot ?? this.update.business_message?.from?.is_bot ?? this.update.guest_message?.from?.is_bot ?? false);
     }
     /**
      * Parse arguments from the update
@@ -66,7 +63,7 @@ export default class TelegramExecutionContext {
             case 'message':
             case 'business_message':
             case 'guest_message':
-                return (this.update.message?.text ?? this.update.business_message?.text ?? this.update.guest_message?.text)?.toString().split(' ') ?? [];
+                return ((this.update.message?.text ?? this.update.business_message?.text ?? this.update.guest_message?.text)?.toString().split(' ') ?? []);
             case 'inline':
                 return this.update.inline_query?.query.split(' ') ?? [];
             default:
@@ -97,7 +94,7 @@ export default class TelegramExecutionContext {
             try {
                 const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
                 if (response.status === 200) {
-                    const json = await response.json();
+                    const json = (await response.json());
                     if (json.ok && json.result) {
                         ownerId = json.result.user?.id || json.result.user_chat_id;
                         if (ownerId) {
@@ -217,7 +214,7 @@ export default class TelegramExecutionContext {
                 try {
                     const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
                     if (response.status === 200) {
-                        const json = await response.json();
+                        const json = (await response.json());
                         if (json.ok && json.result) {
                             ownerId = json.result.user?.id || json.result.user_chat_id;
                             if (ownerId) {
@@ -278,7 +275,9 @@ export default class TelegramExecutionContext {
             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' }],
+                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);
@@ -377,7 +376,14 @@ export default class TelegramExecutionContext {
         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: 'article', id: crypto.randomUUID(), title: title ?? '', input_message_content: { message_text: message, parse_mode: parse_mode } }],
+                results: [
+                    {
+                        type: 'article',
+                        id: crypto.randomUUID(),
+                        title: title ?? '',
+                        input_message_content: { message_text: message, parse_mode: parse_mode },
+                    },
+                ],
             });
         }
         return null;
@@ -400,7 +406,12 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryText(message, parse_mode = '') {
-        return await this.answerGuestQuery({ type: 'article', id: crypto.randomUUID(), title: 'Response', input_message_content: { message_text: message, parse_mode: parse_mode } });
+        return await this.answerGuestQuery({
+            type: 'article',
+            id: crypto.randomUUID(),
+            title: 'Response',
+            input_message_content: { message_text: message, parse_mode: parse_mode },
+        });
     }
     /**
      * Answer a guest query with a photo
@@ -410,7 +421,14 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryPhoto(photo, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery({ type: 'photo', id: crypto.randomUUID(), photo_url: photo, thumbnail_url: photo, caption, parse_mode: parse_mode });
+        return await this.answerGuestQuery({
+            type: 'photo',
+            id: crypto.randomUUID(),
+            photo_url: photo,
+            thumbnail_url: photo,
+            caption,
+            parse_mode: parse_mode,
+        });
     }
     /**
      * Answer a guest query with a video
@@ -420,7 +438,16 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryVideo(video, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery({ type: 'video', id: crypto.randomUUID(), video_url: video, mime_type: 'video/mp4', thumbnail_url: video, title: 'Video', caption, parse_mode: parse_mode });
+        return await this.answerGuestQuery({
+            type: 'video',
+            id: crypto.randomUUID(),
+            video_url: video,
+            mime_type: 'video/mp4',
+            thumbnail_url: video,
+            title: 'Video',
+            caption,
+            parse_mode: parse_mode,
+        });
     }
     /**
      * Answer a guest query with a voice message
@@ -430,7 +457,14 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryVoice(voice, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery({ type: 'voice', id: crypto.randomUUID(), voice_url: voice, title: 'Voice', caption, parse_mode: parse_mode });
+        return await this.answerGuestQuery({
+            type: 'voice',
+            id: crypto.randomUUID(),
+            voice_url: voice,
+            title: 'Voice',
+            caption,
+            parse_mode: parse_mode,
+        });
     }
     /** Map of draft IDs to message IDs for streaming */
     drafts = new Map();

package/dist/utils.js

@@ -21,7 +21,7 @@ export async function markdownToHtml(s) {
         let result = '';
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
-            const prefix = ordered ? `${(start !== '' && start !== undefined) ? Number(start) + i : i + 1}. ` : '• ';
+            const prefix = ordered ? `${start !== '' && start !== undefined ? Number(start) + i : i + 1}. ` : '• ';
             result += `${prefix}${renderer.listitem(item)}\n`;
         }
         return result;
@@ -50,8 +50,21 @@ export async function markdownToHtml(s) {
     // html tag pass-through for supported tags or escaping
     renderer.html = ({ text }) => {
         const allowedTags = [
-            'b', 'strong', 'i', 'em', 'u', 'ins', 's', 'strike', 'del',
-            'span', 'tg-spoiler', 'a', 'code', 'pre', 'blockquote'
+            'b',
+            'strong',
+            'i',
+            'em',
+            'u',
+            'ins',
+            's',
+            'strike',
+            'del',
+            'span',
+            'tg-spoiler',
+            'a',
+            'code',
+            'pre',
+            'blockquote',
         ];
         const match = /^<\/?([a-z0-9-]+)(?:\s+[^>]*)?>/i.exec(text);
         if (match) {
@@ -87,9 +100,9 @@ export const fetchTool = {
             url: { type: 'string', description: 'The URL to fetch' },
             method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'], default: 'GET' },
             headers: { type: 'object', description: 'HTTP headers to include in the request' },
-            body: { type: 'string', description: 'The request body' }
+            body: { type: 'string', description: 'The request body' },
         },
-        required: ['url']
+        required: ['url'],
     },
     function: async ({ url, method, headers, body }) => {
         try {
@@ -97,9 +110,9 @@ export const fetchTool = {
                 method: method || 'GET',
                 headers: {
                     'User-Agent': 'Mozilla/5.0 (Cloudflare Worker Telegram Bot)',
-                    ...headers
+                    ...headers,
                 },
-                body: body ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined
+                body: body ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined,
             });
             const text = await res.text();
             return text.slice(0, 10000);
@@ -107,5 +120,5 @@ export const fetchTool = {
         catch (e) {
             return `Error executing fetch: ${String(e)}`;
         }
-    }
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codebam/cf-workers-telegram-bot",
-	"version": "12.6.2",
+	"version": "12.6.5",
 	"description": "serverless telegram bot on cf workers",
 	"main": "./dist/main.js",
 	"module": "./dist/main.js",
@@ -22,11 +22,18 @@
 	},
 	"scripts": {
 		"build": "tsc --project tsconfig.json",
+		"build:all": "npm run build && npm run build --prefix ai-workflow && npm run build --prefix consumer && npm run build --prefix webapp",
 		"lint": "eslint src",
+		"lint:all": "npm run lint && npm run lint --prefix ai-workflow && npm run lint --prefix consumer && npm run lint --prefix webapp",
 		"test": "vitest --config vitest.config.js",
+		"test:all": "npm test && npm test --prefix ai-workflow && npm test --prefix consumer && npm test --prefix webapp",
+		"format": "prettier --write src test *.json *.js *.mjs",
+		"format:check": "prettier --check src test *.json *.js *.mjs",
 		"docs": "typedoc --options typedoc.json",
 		"deploy:docs": "npm run docs && wrangler pages deploy docs",
-		"ncu": "npx npm-check-updates -i --root -u"
+		"ncu": "npx npm-check-updates -u --root",
+		"ncu:interactive": "npx npm-check-updates -i --root",
+		"prepare": "./setup_hooks.sh"
 	},
 	"author": "codebam",
 	"license": "Apache-2.0",
@@ -35,13 +42,16 @@
 		"url": "git+https://github.com/codebam/cf-workers-telegram-bot.git"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20260511.1",
+		"@cloudflare/vitest-pool-workers": "^0.16.6",
+		"@eslint/compat": "^2.1.0",
 		"@eslint/js": "^10.0.1",
+		"@types/node": "^25.8.0",
 		"@typescript-eslint/eslint-plugin": "^8.59.3",
 		"@typescript-eslint/parser": "^8.59.3",
-		"eslint": "^10.3.0",
+		"eslint": "^10.4.0",
 		"eslint-config-prettier": "^10.1.8",
 		"globals": "^17.6.0",
+		"lint-staged": "^17.0.5",
 		"npm-check-updates": "^22.2.0",
 		"prettier": "^3.8.3",
 		"typedoc": "^0.28.19",
@@ -49,16 +59,22 @@
 		"typescript": "^6.0.3",
 		"typescript-eslint": "^8.59.3",
 		"vitest": "^4.1.6",
-		"wrangler": "^4.90.1"
+		"wrangler": "^4.92.0"
 	},
 	"dependencies": {
 		"@eslint/eslintrc": "^3.3.5",
-		"@grammyjs/types": "^3.27.2",
+		"@grammyjs/types": "^3.27.3",
 		"marked": "^18.0.3"
 	},
 	"typedocOptions": {
 		"entryPoints": [
 			"./src/main.ts"
 		]
+	},
+	"lint-staged": {
+		"*.{ts,js,mjs,json}": [
+			"prettier --write",
+			"eslint --fix"
+		]
 	}
 }