@codebam/cf-workers-telegram-bot 6.6.0 → 7.4.0

package/README.md

@@ -1,22 +1,47 @@
-# cf-workers-telegram-bot
-
-[![Deploy to Cloudflare Workers](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/codebam/cf-workers-telegram-bot)
+<h3 align="center">
+<img src="https://raw.githubusercontent.com/codebam/cf-workers-telegram-bot/master/assets/logo.png" width="100" />
+<br/>
+CF workers telegram bot
+<br/>
+</h3>
+
+<h6 align="center">
+<a href="https://github.com/codebam/cf-workers-telegram-bot/wiki">Wiki</a>
+ · 
+<a  href="https://codebam.github.io/cf-workers-telegram-bot-docs/">Docs</a>
+</h6>
+
+<p  align="center">
+<a href="https://github.com/codebam/cf-workers-telegram-bot/stargazers">  <img src="https://img.shields.io/github/stars/codebam/cf-workers-telegram-bot?style=for-the-badge&logo=starship&color=111111&logoColor=ffffff&labelColor=000000" alt="GitHub stars"/></a>
+<a href="https://github.com/codebam/cf-workers-telegram-bot/issues">
+  <img src="https://img.shields.io/github/issues/codebam/cf-workers-telegram-bot?style=for-the-badge&logo=gitbook&color=111111&logoColor=ffffff&labelColor=000000" alt="GitHub issues"/></a>
+<a href="https://github.com/codebam/cf-workers-telegram-bot">  <img src="https://img.shields.io/github/forks/codebam/cf-workers-telegram-bot?style=for-the-badge&logo=git&color=111111&logoColor=ffffff&labelColor=000000" alt="GitHub forks"/></a>
+<a href="https://www.npmjs.com/package/@codebam/cf-workers-telegram-bot">  <img src="https://img.shields.io/npm/v/@codebam/cf-workers-telegram-bot?style=for-the-badge&logo=npm&color=111111&logoColor=ffffff&labelColor=000000" alt="npm version" /></a>
+</p>
 
 ![screenshot of cf-workers-telegram-bot](/screenshot.png)
 
-serverless telegram bot on cf workers
+```sh
+npm i @codebam/cf-workers-telegram-bot
+```
+
+See `worker.ts` for an example of what a bot might look like. Just import from `@codebam/cf-workers-telegram-bot`.
 
-The original `worker.js` is the content of Nikhil John's
-https://github.com/nikhiljohn10/telegram-bot-worker which is licensed with MIT.
-My modifications are licensed under the Apache license.
+- `npm create cloudflare@latest`
+- `npx wrangler login`
+- `npx wrangler secret put SECRET_TELEGRAM_API_TOKEN`, set it to your telegram bot token that you got from `@BotFather`
+- `npx wrangler deploy`
+- Open this url in your browser to set your webhook `https://your-worker.username.workers.dev/SECRET_TELEGRAM_API_TOKEN?command=set`
 
-The first bot configuration is fully featured, and responds to all received
-messages with llama2 if a command isn't found.
+To set up GitHub actions to deploy when you push, see https://github.com/cloudflare/wrangler-action
 
-To get continuous conversation with llama2 working make sure you add a database
-to your wrangler.toml and initailize it with the schema.sql
+---
 
-To use the deploy button:
+These instructions are for if you want to deploy a copy of the bot along with
+the library. Such as if you need extra API requests that haven't been
+implemented yet.
+
+[![Deploy to Cloudflare Workers](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/codebam/cf-workers-telegram-bot)
 
 - Click the deploy button
 - Navigate to your new **GitHub repository &gt; Settings &gt; Secrets** and add the following secrets:
@@ -30,34 +55,3 @@ To use the deploy button:
   ```
 
 - Push to `master` to trigger a deploy
-
-To fork this repo and use wrangler:
-
-- Click fork
-- `npm i -g wrangler`
-- `wrangler secret put SECRET_TELEGRAM_API_TOKEN` and set it to your telegram
-  bot token
-- `wrangler d1 create llama2`
-- put the database block from the command in your wrangler.toml
-- `wrangler d1 execute --remote llama2 --file ./schema.sql`
-- `wrangler deploy`
-- Done!
-
-## Getting started with cf-workers-telegram-bot
-
-Once you've deployed the bot you can get your Webhook command URL by doing any
-of the following.
-
-- sha256sum(SECRET_TELEGRAM_API_TOKEN) is the path to your webhook commands and
-  should be put at the end of your worker URL to access commands such as
-  setting your webhook
-- Use `echo -n yoursecretkey | sha256sum` to get the path
-- Open the Cloudflare Worker Logs under **Workers &gt; cf-workers-telegram-bot
-  &gt; Logs &gt; Begin log stream** and make a GET request (open it in your browser)
-  to your Worker URL and look at the logs to see your Access URL
-- Run `wrangler tail --format pretty` from inside your git repository and make
-  a GET request to your Worker URL
-
-Example URL for setting the Webhook and dropping pending updates:
-
-`https://cf-workers-telegram-bot.codebam.workers.dev/a948904f2f0f479b8f8197694b30184b0d2ed1c1cd2a1ec0fb85d299a192a447?command=set`

package/dist/main/src/main.d.ts

@@ -1,11 +1,4 @@
-import BotApi from './bot_api';
-import Handler from './handler';
-import * as Libs from './libs';
-import TelegramApi from './telegram_api';
 import TelegramBot from './telegram_bot';
-import TelegramCommands from './telegram_commands';
-import TelegramWebhook from './telegram_webhook';
 import * as Types from './types';
-import Webhook from './webhook';
 import worker from '../../worker/src/worker';
-export { BotApi, Handler, Libs, TelegramApi, TelegramBot, TelegramCommands, TelegramWebhook, Types, Webhook, worker };
+export { TelegramBot, Types, worker };

package/dist/main/src/main.js

@@ -1,11 +1,4 @@
-import BotApi from './bot_api';
-import Handler from './handler';
-import * as Libs from './libs';
-import TelegramApi from './telegram_api';
 import TelegramBot from './telegram_bot';
-import TelegramCommands from './telegram_commands';
-import TelegramWebhook from './telegram_webhook';
 import * as Types from './types';
-import Webhook from './webhook';
 import worker from '../../worker/src/worker';
-export { BotApi, Handler, Libs, TelegramApi, TelegramBot, TelegramCommands, TelegramWebhook, Types, Webhook, worker };
+export { TelegramBot, Types, worker };

package/dist/main/src/telegram_bot.d.ts

@@ -1,34 +1,20 @@
 /// <reference types="@cloudflare/workers-types" />
-import TelegramApi from './telegram_api';
-import { Config, Kv, TelegramUpdate } from './types';
-export default class TelegramBot extends TelegramApi {
-    translate: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    clear: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    image: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    question: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    sean: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    code: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    duckduckgo: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    kanye: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    joke: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    dog: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    bored: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    epoch: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    roll: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    commandList: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    toss: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    ping: (self: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
-    getChatInfo: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    start: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    ban: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    mute: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-    url: URL;
-    kv: Kv;
-    get_set: KVNamespace;
-    ai: Ai;
-    db: D1Database;
-    r2: R2Bucket;
-    bot_name: string;
-    chat_model: string;
-    constructor(config: Config);
+import { TelegramUpdate } from './types';
+export default class TelegramBot {
+    token: string;
+    webhook: Webhook;
+    update: TelegramUpdate;
+    api: URL;
+    update_type: string;
+    constructor(token: string);
+    on(event: string, callback: () => Promise<Response>): this;
+    handle(request: Request): Promise<any>;
+    reply(message: string): Promise<void>;
 }
+declare class Webhook {
+    api: URL;
+    webhook: URL;
+    constructor(token: string, request: Request);
+    set(): Promise<Response>;
+}
+export {};

package/dist/main/src/telegram_bot.js

@@ -1,82 +1,116 @@
-import TelegramApi from './telegram_api';
-import translate from './commands/translate';
-import clear from './commands/clear';
-import image from './commands/image';
-import question from './commands/question';
-import sean from './commands/sean';
-import code from './commands/code';
-import duckduckgo from './commands/duckduckgo';
-import kanye from './commands/kanye';
-import joke from './commands/joke';
-import dog from './commands/dog';
-import bored from './commands/bored';
-import epoch from './commands/epoch';
-import roll from './commands/roll';
-import commandlist from './commands/commandlist';
-import toss from './commands/toss';
-import ping from './commands/ping';
-import getchatinfo from './commands/getchatinfo';
-import start from './commands/start';
-import ban from './commands/ban';
-import mute from './commands/mute';
-export default class TelegramBot extends TelegramApi {
-    translate;
-    clear;
-    image;
-    question;
-    sean;
-    code;
-    duckduckgo;
-    kanye;
-    joke;
-    dog;
-    bored;
-    epoch;
-    roll;
-    commandList;
-    toss;
-    ping;
-    getChatInfo;
-    start;
-    ban;
-    mute;
-    url;
-    kv;
-    get_set;
-    ai;
-    db;
-    r2;
-    bot_name;
-    chat_model;
-    constructor(config) {
-        super(config.commands, config.webhook, config.handler);
-        this.translate = translate;
-        this.clear = clear;
-        this.image = image;
-        this.question = question;
-        this.sean = sean;
-        this.code = code;
-        this.duckduckgo = duckduckgo;
-        this.kanye = kanye;
-        this.joke = joke;
-        this.dog = dog;
-        this.bored = bored;
-        this.epoch = epoch;
-        this.roll = roll;
-        this.commandList = commandlist;
-        this.toss = toss;
-        this.ping = ping;
-        this.getChatInfo = getchatinfo;
-        this.start = start;
-        this.ban = ban;
-        this.mute = mute;
-        this.url = config.url;
-        this.kv = config.kv;
-        this.get_set = config.kv?.get_set;
-        this.ai = config.ai;
-        this.db = config.db;
-        this.r2 = config.r2;
-        this.bot_name = config.bot_name;
-        this.chat_model = config.chat_model;
+import { TelegramInlineQueryResultArticle, TelegramUpdate } from './types';
+export default class TelegramBot {
+    token;
+    webhook;
+    update;
+    api;
+    update_type;
+    constructor(token) {
+        this.token = token;
+        this.webhook = new Webhook('', new Request('http://127.0.0.1'));
+        this.update = new TelegramUpdate({});
+        this.api = new URL('https://api.telegram.org/bot' + token);
+        this.update_type = '';
+    }
+    on(event, callback) {
+        if (event !== 'on') {
+            // eslint-disable-next-line
+            // @ts-ignore TS7053
+            this[event] = callback;
+        }
+        return this;
+    }
+    async handle(request) {
+        this.webhook = new Webhook(this.token, request);
+        if (request.method === 'POST') {
+            this.update = await request.json();
+        }
+        const url = new URL(request.url);
+        if (`/${this.token}` === url.pathname) {
+            switch (url.searchParams.get('command')) {
+                case 'set':
+                    return this.webhook.set();
+                default:
+                    break;
+            }
+            console.log(this.update);
+            if (this.update.message?.text) {
+                this.update_type = 'message';
+            }
+            else if (this.update.inline_query?.query) {
+                this.update_type = 'inline';
+            }
+            let command = 'default';
+            let args = [];
+            switch (this.update_type) {
+                case 'message': {
+                    // @ts-expect-error already checked above
+                    args = this.update.message.text.split(' ');
+                    break;
+                }
+                case 'inline': {
+                    // @ts-expect-error already checked above
+                    args = this.update.inline_query.query.split(' ');
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (args.at(0)?.startsWith('/')) {
+                // @ts-expect-error already checked above
+                command = args.at(0).slice(1);
+            }
+            // eslint-disable-next-line
+            // @ts-ignore
+            if (!this[command] || command === 'on') {
+                command = 'default';
+            }
+            // eslint-disable-next-line
+            // @ts-ignore
+            return this[command]?.();
+        }
+        return new Response('ok');
+    }
+    async reply(message) {
+        switch (this.update_type) {
+            case 'message': {
+                const request = new URL(this.api + '/sendMessage');
+                const params = new URLSearchParams();
+                params.append('chat_id', this.update.message?.chat.id.toString() ?? '');
+                params.append('reply_to_message_id', this.update.message?.message_id.toString() ?? '');
+                params.append('text', message);
+                console.log(`${request}?${params}`);
+                await fetch(`${request}?${params}`);
+                break;
+            }
+            case 'inline': {
+                const inline_request = new URL(this.api + '/answerInlineQuery');
+                const inline_params = new URLSearchParams();
+                inline_params.append('inline_query_id', this.update.inline_query?.id.toString() ?? '');
+                inline_params.append('results', JSON.stringify([new TelegramInlineQueryResultArticle(message)]));
+                console.log(`${inline_request}?${inline_params}`);
+                await fetch(`${inline_request}?${inline_params}`);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}
+class Webhook {
+    api;
+    webhook;
+    constructor(token, request) {
+        this.api = new URL('https://api.telegram.org/bot' + token);
+        this.webhook = new URL(new URL(request.url).origin + `/${token}`);
+    }
+    async set() {
+        const url = new URL(`${this.api.origin}${this.api.pathname}/setWebhook`);
+        const params = url.searchParams;
+        params.append('url', this.webhook.toString());
+        params.append('max_connections', '100');
+        params.append('allowed_updates', JSON.stringify(['message', 'inline_query']));
+        params.append('drop_pending_updates', 'true');
+        return await fetch(`${url}?${params}`);
     }
 }

package/dist/main/src/types.d.ts

@@ -1,9 +1,5 @@
-import Webhook from './webhook';
-import Command from './types/Command';
 import TelegramCommand from './types/TelegramCommand';
-import Commands from './types/Commands';
 import Kv from './types/Kv';
-import Config from './types/Config';
 import localhost from './types/localhost';
 import WebhookCommands from './types/WebhookCommands';
 import Joke from './types/Joke';
@@ -27,4 +23,4 @@ import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultA
 import DDGQueryResponse from './types/DDGQueryResponse';
 import ChatPermissions from './types/ChatPermissions';
 import Kanye from './types/Kanye';
-export { Webhook, Command, TelegramCommand, Commands, Kv, Config, localhost, WebhookCommands, Joke, Bored, Balance, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramInputMessageContent, TelegramInlineQuery, Update, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, DDGQueryResponse, ChatPermissions, Kanye, };
+export { TelegramCommand, Kv, localhost, WebhookCommands, Joke, Bored, Balance, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramInputMessageContent, TelegramInlineQuery, Update, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, DDGQueryResponse, ChatPermissions, Kanye, };

package/dist/main/src/types.js

@@ -1,5 +1,3 @@
-import Webhook from './webhook';
-import Config from './types/Config';
 import localhost from './types/localhost';
 import WebhookCommands from './types/WebhookCommands';
 import Update from './types/Update';
@@ -7,4 +5,4 @@ import TelegramUpdate from './types/TelegramUpdate';
 import TelegramInlineQueryResult from './types/TelegramInlineQueryResult';
 import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto';
 import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle';
-export { Webhook, Config, localhost, WebhookCommands, Update, TelegramUpdate, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, };
+export { localhost, WebhookCommands, Update, TelegramUpdate, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, };

package/dist/worker/src/worker.js

@@ -1,94 +1,80 @@
-import { TelegramCommands, Handler, TelegramWebhook, TelegramBot } from '../../main/src/main';
+import TelegramBot from '../../main/src/telegram_bot';
 export default {
-    fetch: async (request, env) => new Handler([
-        {
-            bot_name: '@TuxRobot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN}`), env.SECRET_TELEGRAM_API_TOKEN, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.question,
-                inline: TelegramCommands.question,
-                '/ping': TelegramCommands.ping,
-                '/toss': TelegramCommands.toss,
-                '/epoch': TelegramCommands.epoch,
-                '/kanye': TelegramCommands.kanye,
-                '/bored': TelegramCommands.bored,
-                '/joke': TelegramCommands.joke,
-                '/dog': TelegramCommands.dog,
-                '/roll': TelegramCommands.roll,
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/question': TelegramCommands.question,
-                '/clear': TelegramCommands.clear,
-                '/help': TelegramCommands.commandList,
-                '/image': TelegramCommands.image,
-                '/start': TelegramCommands.start,
-                '/ban': TelegramCommands.ban,
-                '/mute': TelegramCommands.mute,
-            },
-            kv: { get_set: env.KV_GET_SET, uid_data: env.KV_UID_DATA },
-            ai: env.AI,
-            db: env.DB,
-            r2: env.R2,
-            chat_model: env.CHAT_MODEL,
-        },
-        {
-            bot_name: '@duckduckbot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN2}`), env.SECRET_TELEGRAM_API_TOKEN2, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.duckduckgo,
-                inline: TelegramCommands.duckduckgo, // default inline response
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/question': TelegramCommands.question,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/help': TelegramCommands.commandList,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            bot_name: '@ddggbot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN3}`), env.SECRET_TELEGRAM_API_TOKEN3, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.duckduckgo,
-                inline: TelegramCommands.duckduckgo,
-                '/duckduckgo': TelegramCommands.duckduckgo,
-                '/question': TelegramCommands.question,
-                '/code': TelegramCommands.code,
-                '/commands': TelegramCommands.commandList,
-                '/help': TelegramCommands.commandList,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            bot_name: '@SeanB_robot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN4}`), env.SECRET_TELEGRAM_API_TOKEN4, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.sean,
-                '/clear': TelegramCommands.clear,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-            db: env.DB,
-        },
-        {
-            bot_name: '@TranslatePartyBot',
-            api: TelegramBot,
-            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN5}`), env.SECRET_TELEGRAM_API_TOKEN5, new URL(new URL(request.url).origin)),
-            commands: {
-                default: TelegramCommands.translate,
-                inline: TelegramCommands.translate,
-                '/start': TelegramCommands.commandList,
-            },
-            ai: env.AI,
-        },
-    ]).handle(request),
+    fetch: async (request, env) => {
+        const bot = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN);
+        await bot
+            .on('default', async function () {
+            switch (bot.update_type) {
+                case 'message': {
+                    const messages = [
+                        { role: 'system', content: 'You are a friendly assistant' },
+                        {
+                            role: 'user',
+                            content: bot.update.message?.text?.toString() ?? '',
+                        },
+                    ];
+                    const response = await env.AI.run('@cf/meta/llama-3-8b-instruct', { messages });
+                    if ('response' in response) {
+                        await bot.reply(response.response ?? '');
+                    }
+                    break;
+                }
+                case 'inline': {
+                    const inline_messages = [
+                        { role: 'system', content: 'You are a friendly assistant' },
+                        {
+                            role: 'user',
+                            content: bot.update.inline_query?.query.toString() ?? '',
+                        },
+                    ];
+                    const inline_response = await env.AI.run('@cf/meta/llama-3-8b-instruct', { messages: inline_messages, max_tokens: 50 });
+                    if ('response' in inline_response) {
+                        await bot.reply(inline_response.response ?? '');
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        const bot2 = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN2);
+        await bot2
+            .on('default', async function () {
+            switch (bot2.update_type) {
+                case 'message': {
+                    await bot2.reply('https://duckduckgo.com/?q=' + encodeURIComponent(bot.update.message?.text?.toString() ?? ''));
+                    break;
+                }
+                case 'inline': {
+                    await bot2.reply('https://duckduckgo.com/?q=' + encodeURIComponent(bot.update.inline_query?.query ?? ''));
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        const bot3 = new TelegramBot(env.SECRET_TELEGRAM_API_TOKEN3);
+        await bot3
+            .on('default', async function () {
+            switch (bot3.update_type) {
+                case 'inline': {
+                    const translated_text = await fetch('https://clients5.google.com/translate_a/t?client=at&sl=auto&tl=en&q=' +
+                        encodeURIComponent(bot3.update.inline_query?.query.toString() ?? ''))
+                        .then((r) => r.json())
+                        .then((json) => json[0].slice(0, -1).join(' '));
+                    await bot3.reply(translated_text ?? '');
+                    break;
+                }
+                default:
+                    break;
+            }
+            return new Response('ok');
+        })
+            .handle(request.clone());
+        return new Response('ok');
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebam/cf-workers-telegram-bot",
-  "version": "6.6.0",
+  "version": "7.4.0",
   "description": "serverless telegram bot on cf workers",
   "main": "./dist/main/src/main.js",
   "module": "./dist/main/src/main.js",
@@ -35,11 +35,11 @@
     "@typescript-eslint/parser": "^7.8.0",
     "eslint": "^9.2.0",
     "eslint-config-prettier": "^9.1.0",
-    "globals": "^15.1.0",
+    "globals": "^15.2.0",
     "lerna": "^8.1.2",
     "prettier": "^3.2.5",
     "typescript": "^5.4.5",
     "typescript-eslint": "^7.8.0"
   },
-  "gitHead": "ac79b5c72e1c5379d512ea35dff333c0aca0ff2c"
+  "gitHead": "5a413513b05d2cde80b76d4e901dbe334e95ed25"
 }

package/dist/main/src/bot_api.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-import Handler from './handler';
-import { Commands, Config, Update } from './types';
-export default class BotApi {
-    commands: Commands;
-    webhook: Config['webhook'];
-    handler: Handler;
-    update: (update: Update) => Promise<Response>;
-    constructor(config: Partial<Config>);
-}

package/dist/main/src/bot_api.js

@@ -1,11 +0,0 @@
-export default class BotApi {
-    commands;
-    webhook;
-    handler;
-    update;
-    constructor(config) {
-        this.commands = config.commands;
-        this.webhook = config.webhook;
-        this.handler = config.handler;
-    }
-}

package/dist/main/src/commands/ban.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-import TelegramBot from '../telegram_bot';
-import { TelegramUpdate } from '../types';
-declare const _default: (self: TelegramBot, update: TelegramUpdate) => Promise<Response>;
-export default _default;