clawdbot 2026.1.4-1

package/dist/slack/probe.js

@@ -0,0 +1,47 @@
+import { WebClient } from "@slack/web-api";
+function withTimeout(promise, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return promise;
+    let timer = null;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+export async function probeSlack(token, timeoutMs = 2500) {
+    const client = new WebClient(token);
+    const start = Date.now();
+    try {
+        const result = await withTimeout(client.auth.test(), timeoutMs);
+        if (!result.ok) {
+            return {
+                ok: false,
+                status: 200,
+                error: result.error ?? "unknown",
+                elapsedMs: Date.now() - start,
+            };
+        }
+        return {
+            ok: true,
+            status: 200,
+            elapsedMs: Date.now() - start,
+            bot: { id: result.user_id ?? undefined, name: result.user ?? undefined },
+            team: { id: result.team_id ?? undefined, name: result.team ?? undefined },
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const status = typeof err.status === "number"
+            ? err.status
+            : null;
+        return {
+            ok: false,
+            status,
+            error: message,
+            elapsedMs: Date.now() - start,
+        };
+    }
+}

package/dist/slack/send.js

@@ -0,0 +1,131 @@
+import { WebClient } from "@slack/web-api";
+import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { loadConfig } from "../config/config.js";
+import { loadWebMedia } from "../web/media.js";
+import { resolveSlackBotToken } from "./token.js";
+const SLACK_TEXT_LIMIT = 4000;
+function resolveToken(explicit) {
+    const cfgToken = loadConfig().slack?.botToken;
+    const token = resolveSlackBotToken(explicit ?? process.env.SLACK_BOT_TOKEN ?? cfgToken ?? undefined);
+    if (!token) {
+        throw new Error("SLACK_BOT_TOKEN or slack.botToken is required for Slack sends");
+    }
+    return token;
+}
+function parseRecipient(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Recipient is required for Slack sends");
+    }
+    const mentionMatch = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+    if (mentionMatch) {
+        return { kind: "user", id: mentionMatch[1] };
+    }
+    if (trimmed.startsWith("user:")) {
+        return { kind: "user", id: trimmed.slice("user:".length) };
+    }
+    if (trimmed.startsWith("channel:")) {
+        return { kind: "channel", id: trimmed.slice("channel:".length) };
+    }
+    if (trimmed.startsWith("slack:")) {
+        return { kind: "user", id: trimmed.slice("slack:".length) };
+    }
+    if (trimmed.startsWith("@")) {
+        const candidate = trimmed.slice(1);
+        if (!/^[A-Z0-9]+$/i.test(candidate)) {
+            throw new Error("Slack DMs require a user id (use user:<id> or <@id>)");
+        }
+        return { kind: "user", id: candidate };
+    }
+    if (trimmed.startsWith("#")) {
+        const candidate = trimmed.slice(1);
+        if (!/^[A-Z0-9]+$/i.test(candidate)) {
+            throw new Error("Slack channels require a channel id (use channel:<id>)");
+        }
+        return { kind: "channel", id: candidate };
+    }
+    return { kind: "channel", id: trimmed };
+}
+async function resolveChannelId(client, recipient) {
+    if (recipient.kind === "channel") {
+        return { channelId: recipient.id };
+    }
+    const response = await client.conversations.open({ users: recipient.id });
+    const channelId = response.channel?.id;
+    if (!channelId) {
+        throw new Error("Failed to open Slack DM channel");
+    }
+    return { channelId, isDm: true };
+}
+async function uploadSlackFile(params) {
+    const { buffer, contentType, fileName } = await loadWebMedia(params.mediaUrl, params.maxBytes);
+    const basePayload = {
+        channel_id: params.channelId,
+        file: buffer,
+        filename: fileName,
+        ...(params.caption ? { initial_comment: params.caption } : {}),
+        ...(contentType ? { filetype: contentType } : {}),
+    };
+    const payload = params.threadTs
+        ? { ...basePayload, thread_ts: params.threadTs }
+        : basePayload;
+    const response = await params.client.files.uploadV2(payload);
+    const parsed = response;
+    const fileId = parsed.files?.[0]?.id ??
+        parsed.file?.id ??
+        parsed.files?.[0]?.name ??
+        parsed.file?.name ??
+        "unknown";
+    return fileId;
+}
+export async function sendMessageSlack(to, message, opts = {}) {
+    const trimmedMessage = message?.trim() ?? "";
+    if (!trimmedMessage && !opts.mediaUrl) {
+        throw new Error("Slack send requires text or media");
+    }
+    const token = resolveToken(opts.token);
+    const client = opts.client ?? new WebClient(token);
+    const recipient = parseRecipient(to);
+    const { channelId } = await resolveChannelId(client, recipient);
+    const cfg = loadConfig();
+    const textLimit = resolveTextChunkLimit(cfg, "slack");
+    const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
+    const chunks = chunkText(trimmedMessage, chunkLimit);
+    const mediaMaxBytes = typeof cfg.slack?.mediaMaxMb === "number"
+        ? cfg.slack.mediaMaxMb * 1024 * 1024
+        : undefined;
+    let lastMessageId = "";
+    if (opts.mediaUrl) {
+        const [firstChunk, ...rest] = chunks;
+        lastMessageId = await uploadSlackFile({
+            client,
+            channelId,
+            mediaUrl: opts.mediaUrl,
+            caption: firstChunk,
+            threadTs: opts.threadTs,
+            maxBytes: mediaMaxBytes,
+        });
+        for (const chunk of rest) {
+            const response = await client.chat.postMessage({
+                channel: channelId,
+                text: chunk,
+                thread_ts: opts.threadTs,
+            });
+            lastMessageId = response.ts ?? lastMessageId;
+        }
+    }
+    else {
+        for (const chunk of chunks.length ? chunks : [""]) {
+            const response = await client.chat.postMessage({
+                channel: channelId,
+                text: chunk,
+                thread_ts: opts.threadTs,
+            });
+            lastMessageId = response.ts ?? lastMessageId;
+        }
+    }
+    return {
+        messageId: lastMessageId || "unknown",
+        channelId,
+    };
+}

package/dist/slack/token.js

@@ -0,0 +1,10 @@
+export function normalizeSlackToken(raw) {
+    const trimmed = raw?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function resolveSlackBotToken(raw) {
+    return normalizeSlackToken(raw);
+}
+export function resolveSlackAppToken(raw) {
+    return normalizeSlackToken(raw);
+}

package/dist/telegram/bot.js

@@ -0,0 +1,394 @@
+// @ts-nocheck
+import { Buffer } from "node:buffer";
+import { apiThrottler } from "@grammyjs/transformer-throttler";
+import { Bot, InputFile, webhookCallback } from "grammy";
+import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { formatAgentEnvelope } from "../auto-reply/envelope.js";
+import { getReplyFromConfig } from "../auto-reply/reply.js";
+import { loadConfig } from "../config/config.js";
+import { resolveStorePath, updateLastRoute } from "../config/sessions.js";
+import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
+import { formatErrorMessage } from "../infra/errors.js";
+import { getChildLogger } from "../logging.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { detectMime } from "../media/mime.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { loadWebMedia } from "../web/media.js";
+const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+export function createTelegramBot(opts) {
+    const runtime = opts.runtime ?? {
+        log: console.log,
+        error: console.error,
+        exit: (code) => {
+            throw new Error(`exit ${code}`);
+        },
+    };
+    const client = opts.proxyFetch
+        ? { fetch: opts.proxyFetch }
+        : undefined;
+    const bot = new Bot(opts.token, { client });
+    bot.api.config.use(apiThrottler());
+    const cfg = loadConfig();
+    const textLimit = resolveTextChunkLimit(cfg, "telegram");
+    const allowFrom = opts.allowFrom ?? cfg.telegram?.allowFrom;
+    const replyToMode = opts.replyToMode ?? cfg.telegram?.replyToMode ?? "off";
+    const mediaMaxBytes = (opts.mediaMaxMb ?? cfg.telegram?.mediaMaxMb ?? 5) * 1024 * 1024;
+    const logger = getChildLogger({ module: "telegram-auto-reply" });
+    const resolveGroupRequireMention = (chatId) => {
+        const groupId = String(chatId);
+        const groupConfig = cfg.telegram?.groups?.[groupId];
+        if (typeof groupConfig?.requireMention === "boolean") {
+            return groupConfig.requireMention;
+        }
+        const groupDefault = cfg.telegram?.groups?.["*"]?.requireMention;
+        if (typeof groupDefault === "boolean")
+            return groupDefault;
+        if (typeof opts.requireMention === "boolean")
+            return opts.requireMention;
+        return true;
+    };
+    bot.on("message", async (ctx) => {
+        try {
+            const msg = ctx.message;
+            if (!msg)
+                return;
+            const chatId = msg.chat.id;
+            const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
+            const sendTyping = async () => {
+                try {
+                    await bot.api.sendChatAction(chatId, "typing");
+                }
+                catch (err) {
+                    logVerbose(`telegram typing cue failed for chat ${chatId}: ${String(err)}`);
+                }
+            };
+            // allowFrom for direct chats
+            if (!isGroup && Array.isArray(allowFrom) && allowFrom.length > 0) {
+                const candidate = String(chatId);
+                const allowed = allowFrom.map(String);
+                const allowedWithPrefix = allowFrom.map((v) => `telegram:${String(v)}`);
+                const permitted = allowed.includes(candidate) ||
+                    allowedWithPrefix.includes(`telegram:${candidate}`) ||
+                    allowed.includes("*");
+                if (!permitted) {
+                    logVerbose(`Blocked unauthorized telegram sender ${candidate} (not in allowFrom)`);
+                    return;
+                }
+            }
+            const botUsername = ctx.me?.username?.toLowerCase();
+            const wasMentioned = Boolean(botUsername) && hasBotMention(msg, botUsername);
+            if (isGroup && resolveGroupRequireMention(chatId) && botUsername) {
+                if (!wasMentioned) {
+                    logger.info({ chatId, reason: "no-mention" }, "skipping group message");
+                    return;
+                }
+            }
+            const media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
+            const replyTarget = describeReplyTarget(msg);
+            const rawBody = (msg.text ??
+                msg.caption ??
+                media?.placeholder ??
+                "").trim();
+            if (!rawBody)
+                return;
+            const replySuffix = replyTarget
+                ? `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyTarget.body}\n[/Replying]`
+                : "";
+            const body = formatAgentEnvelope({
+                surface: "Telegram",
+                from: isGroup
+                    ? buildGroupLabel(msg, chatId)
+                    : buildSenderLabel(msg, chatId),
+                timestamp: msg.date ? msg.date * 1000 : undefined,
+                body: `${rawBody}${replySuffix}`,
+            });
+            const ctxPayload = {
+                Body: body,
+                From: isGroup ? `group:${chatId}` : `telegram:${chatId}`,
+                To: `telegram:${chatId}`,
+                ChatType: isGroup ? "group" : "direct",
+                GroupSubject: isGroup ? (msg.chat.title ?? undefined) : undefined,
+                SenderName: buildSenderName(msg),
+                Surface: "telegram",
+                MessageSid: String(msg.message_id),
+                ReplyToId: replyTarget?.id,
+                ReplyToBody: replyTarget?.body,
+                ReplyToSender: replyTarget?.sender,
+                Timestamp: msg.date ? msg.date * 1000 : undefined,
+                WasMentioned: isGroup && botUsername ? wasMentioned : undefined,
+                MediaPath: media?.path,
+                MediaType: media?.contentType,
+                MediaUrl: media?.path,
+            };
+            if (replyTarget && shouldLogVerbose()) {
+                const preview = replyTarget.body.replace(/\s+/g, " ").slice(0, 120);
+                logVerbose(`telegram reply-context: replyToId=${replyTarget.id} replyToSender=${replyTarget.sender} replyToBody="${preview}"`);
+            }
+            if (!isGroup) {
+                const sessionCfg = cfg.session;
+                const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
+                const storePath = resolveStorePath(sessionCfg?.store);
+                await updateLastRoute({
+                    storePath,
+                    sessionKey: mainKey,
+                    channel: "telegram",
+                    to: String(chatId),
+                });
+            }
+            if (shouldLogVerbose()) {
+                const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+                logVerbose(`telegram inbound: chatId=${chatId} from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
+            }
+            let blockSendChain = Promise.resolve();
+            const sendBlockReply = (payload) => {
+                if (!payload?.text &&
+                    !payload?.mediaUrl &&
+                    !(payload?.mediaUrls?.length ?? 0)) {
+                    return;
+                }
+                blockSendChain = blockSendChain
+                    .then(async () => {
+                    await deliverReplies({
+                        replies: [payload],
+                        chatId: String(chatId),
+                        token: opts.token,
+                        runtime,
+                        bot,
+                        replyToMode,
+                        textLimit,
+                    });
+                })
+                    .catch((err) => {
+                    runtime.error?.(danger(`telegram block reply failed: ${String(err)}`));
+                });
+            };
+            const replyResult = await getReplyFromConfig(ctxPayload, { onReplyStart: sendTyping, onBlockReply: sendBlockReply }, cfg);
+            const replies = replyResult
+                ? Array.isArray(replyResult)
+                    ? replyResult
+                    : [replyResult]
+                : [];
+            await blockSendChain;
+            if (replies.length === 0)
+                return;
+            await deliverReplies({
+                replies,
+                chatId: String(chatId),
+                token: opts.token,
+                runtime,
+                bot,
+                replyToMode,
+                textLimit,
+            });
+        }
+        catch (err) {
+            runtime.error?.(danger(`handler failed: ${String(err)}`));
+        }
+    });
+    return bot;
+}
+export function createTelegramWebhookCallback(bot, path = "/telegram-webhook") {
+    return { path, handler: webhookCallback(bot, "http") };
+}
+async function deliverReplies(params) {
+    const { replies, chatId, runtime, bot, replyToMode, textLimit } = params;
+    let hasReplied = false;
+    for (const reply of replies) {
+        if (!reply?.text && !reply?.mediaUrl && !(reply?.mediaUrls?.length ?? 0)) {
+            runtime.error?.(danger("reply missing text/media"));
+            continue;
+        }
+        const replyToId = replyToMode === "off"
+            ? undefined
+            : resolveTelegramReplyId(reply.replyToId);
+        const mediaList = reply.mediaUrls?.length
+            ? reply.mediaUrls
+            : reply.mediaUrl
+                ? [reply.mediaUrl]
+                : [];
+        if (mediaList.length === 0) {
+            for (const chunk of chunkText(reply.text || "", textLimit)) {
+                await sendTelegramText(bot, chatId, chunk, runtime, {
+                    replyToMessageId: replyToId && (replyToMode === "all" || !hasReplied)
+                        ? replyToId
+                        : undefined,
+                });
+                if (replyToId && !hasReplied) {
+                    hasReplied = true;
+                }
+            }
+            continue;
+        }
+        // media with optional caption on first item
+        let first = true;
+        for (const mediaUrl of mediaList) {
+            const media = await loadWebMedia(mediaUrl);
+            const kind = mediaKindFromMime(media.contentType ?? undefined);
+            const file = new InputFile(media.buffer, media.fileName ?? "file");
+            const caption = first ? (reply.text ?? undefined) : undefined;
+            first = false;
+            const replyToMessageId = replyToId && (replyToMode === "all" || !hasReplied)
+                ? replyToId
+                : undefined;
+            if (kind === "image") {
+                await bot.api.sendPhoto(chatId, file, {
+                    caption,
+                    reply_to_message_id: replyToMessageId,
+                });
+            }
+            else if (kind === "video") {
+                await bot.api.sendVideo(chatId, file, {
+                    caption,
+                    reply_to_message_id: replyToMessageId,
+                });
+            }
+            else if (kind === "audio") {
+                await bot.api.sendAudio(chatId, file, {
+                    caption,
+                    reply_to_message_id: replyToMessageId,
+                });
+            }
+            else {
+                await bot.api.sendDocument(chatId, file, {
+                    caption,
+                    reply_to_message_id: replyToMessageId,
+                });
+            }
+            if (replyToId && !hasReplied) {
+                hasReplied = true;
+            }
+        }
+    }
+}
+function buildSenderName(msg) {
+    const name = [msg.from?.first_name, msg.from?.last_name]
+        .filter(Boolean)
+        .join(" ")
+        .trim() || msg.from?.username;
+    return name || undefined;
+}
+function buildSenderLabel(msg, chatId) {
+    const name = buildSenderName(msg);
+    const username = msg.from?.username ? `@${msg.from.username}` : undefined;
+    let label = name;
+    if (name && username) {
+        label = `${name} (${username})`;
+    }
+    else if (!name && username) {
+        label = username;
+    }
+    const idPart = `id:${chatId}`;
+    return label ? `${label} ${idPart}` : idPart;
+}
+function buildGroupLabel(msg, chatId) {
+    const title = msg.chat?.title;
+    if (title)
+        return `${title} id:${chatId}`;
+    return `group:${chatId}`;
+}
+function hasBotMention(msg, botUsername) {
+    const text = (msg.text ?? msg.caption ?? "").toLowerCase();
+    if (text.includes(`@${botUsername}`))
+        return true;
+    const entities = msg.entities ?? msg.caption_entities ?? [];
+    for (const ent of entities) {
+        if (ent.type !== "mention")
+            continue;
+        const slice = (msg.text ?? msg.caption ?? "").slice(ent.offset, ent.offset + ent.length);
+        if (slice.toLowerCase() === `@${botUsername}`)
+            return true;
+    }
+    return false;
+}
+function resolveTelegramReplyId(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    return parsed;
+}
+async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
+    const msg = ctx.message;
+    const m = msg.photo?.[msg.photo.length - 1] ??
+        msg.video ??
+        msg.document ??
+        msg.audio ??
+        msg.voice;
+    if (!m?.file_id)
+        return null;
+    const file = await ctx.getFile();
+    if (!file.file_path) {
+        throw new Error("Telegram getFile returned no file_path");
+    }
+    const fetchImpl = proxyFetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("fetch is not available; set telegram.proxy in config");
+    }
+    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+    const res = await fetchImpl(url);
+    if (!res.ok) {
+        throw new Error(`Failed to download telegram file: HTTP ${res.status} ${res.statusText}`);
+    }
+    const data = Buffer.from(await res.arrayBuffer());
+    const mime = await detectMime({
+        buffer: data,
+        headerMime: res.headers.get("content-type"),
+        filePath: file.file_path,
+    });
+    const saved = await saveMediaBuffer(data, mime, "inbound", maxBytes);
+    let placeholder = "<media:document>";
+    if (msg.photo)
+        placeholder = "<media:image>";
+    else if (msg.video)
+        placeholder = "<media:video>";
+    else if (msg.audio || msg.voice)
+        placeholder = "<media:audio>";
+    return { path: saved.path, contentType: saved.contentType, placeholder };
+}
+async function sendTelegramText(bot, chatId, text, runtime, opts) {
+    try {
+        const res = await bot.api.sendMessage(chatId, text, {
+            parse_mode: "Markdown",
+            reply_to_message_id: opts?.replyToMessageId,
+        });
+        return res.message_id;
+    }
+    catch (err) {
+        const errText = formatErrorMessage(err);
+        if (PARSE_ERR_RE.test(errText)) {
+            runtime.log?.(`telegram markdown parse failed; retrying without formatting: ${errText}`);
+            const res = await bot.api.sendMessage(chatId, text, {
+                reply_to_message_id: opts?.replyToMessageId,
+            });
+            return res.message_id;
+        }
+        throw err;
+    }
+}
+function describeReplyTarget(msg) {
+    const reply = msg.reply_to_message;
+    if (!reply)
+        return null;
+    const replyBody = (reply.text ?? reply.caption ?? "").trim();
+    let body = replyBody;
+    if (!body) {
+        if (reply.photo)
+            body = "<media:image>";
+        else if (reply.video)
+            body = "<media:video>";
+        else if (reply.audio || reply.voice)
+            body = "<media:audio>";
+        else if (reply.document)
+            body = "<media:document>";
+    }
+    if (!body)
+        return null;
+    const sender = buildSenderName(reply);
+    const senderLabel = sender ? `${sender}` : "unknown sender";
+    return {
+        id: reply.message_id ? String(reply.message_id) : undefined,
+        sender: senderLabel,
+        body,
+    };
+}

package/dist/telegram/download.js

@@ -0,0 +1,34 @@
+import { detectMime } from "../media/mime.js";
+import { saveMediaBuffer } from "../media/store.js";
+export async function getTelegramFile(token, fileId) {
+    const res = await fetch(`https://api.telegram.org/bot${token}/getFile?file_id=${encodeURIComponent(fileId)}`);
+    if (!res.ok) {
+        throw new Error(`getFile failed: ${res.status} ${res.statusText}`);
+    }
+    const json = (await res.json());
+    if (!json.ok || !json.result?.file_path) {
+        throw new Error("getFile returned no file_path");
+    }
+    return json.result;
+}
+export async function downloadTelegramFile(token, info, maxBytes) {
+    if (!info.file_path)
+        throw new Error("file_path missing");
+    const url = `https://api.telegram.org/file/bot${token}/${info.file_path}`;
+    const res = await fetch(url);
+    if (!res.ok || !res.body) {
+        throw new Error(`Failed to download telegram file: HTTP ${res.status}`);
+    }
+    const array = Buffer.from(await res.arrayBuffer());
+    const mime = await detectMime({
+        buffer: array,
+        headerMime: res.headers.get("content-type"),
+        filePath: info.file_path,
+    });
+    // save with inbound subdir
+    const saved = await saveMediaBuffer(array, mime, "inbound", maxBytes);
+    // Ensure extension matches mime if possible
+    if (!saved.contentType && mime)
+        saved.contentType = mime;
+    return saved;
+}

package/dist/telegram/index.js

@@ -0,0 +1,4 @@
+export { createTelegramBot, createTelegramWebhookCallback } from "./bot.js";
+export { monitorTelegramProvider } from "./monitor.js";
+export { sendMessageTelegram } from "./send.js";
+export { startTelegramWebhook } from "./webhook.js";

package/dist/telegram/monitor.js

@@ -0,0 +1,47 @@
+import { loadConfig } from "../config/config.js";
+import { createTelegramBot } from "./bot.js";
+import { makeProxyFetch } from "./proxy.js";
+import { resolveTelegramToken } from "./token.js";
+import { startTelegramWebhook } from "./webhook.js";
+export async function monitorTelegramProvider(opts = {}) {
+    const { token } = resolveTelegramToken(loadConfig(), {
+        envToken: opts.token,
+    });
+    if (!token) {
+        throw new Error("TELEGRAM_BOT_TOKEN or telegram.botToken/tokenFile is required for Telegram gateway");
+    }
+    const proxyFetch = opts.proxyFetch ??
+        (loadConfig().telegram?.proxy
+            ? makeProxyFetch(loadConfig().telegram?.proxy)
+            : undefined);
+    const bot = createTelegramBot({
+        token,
+        runtime: opts.runtime,
+        proxyFetch,
+    });
+    if (opts.useWebhook) {
+        await startTelegramWebhook({
+            token,
+            path: opts.webhookPath,
+            port: opts.webhookPort,
+            secret: opts.webhookSecret,
+            runtime: opts.runtime,
+            fetch: proxyFetch,
+            abortSignal: opts.abortSignal,
+            publicUrl: opts.webhookUrl,
+        });
+        return;
+    }
+    // Long polling
+    const stopOnAbort = () => {
+        if (opts.abortSignal?.aborted)
+            void bot.stop();
+    };
+    opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+    try {
+        await bot.start();
+    }
+    finally {
+        opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+    }
+}