@5ss/ai-tools 2.11.1

package/dist/telegram-DDXWzkfL.js

@@ -0,0 +1,734 @@
+import { t as ToolError } from "./errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "./define-CvpJ_pNP.js";
+import { n as requireAuth } from "./provider-CgDAlg6K.js";
+import { t as HttpService } from "./http-service-DDNCO1s4.js";
+import { a as toArrayBuffer, n as bytesToBase64, t as base64ToBytes } from "./bytes-BxpimpQx.js";
+import { isPlainObject, isString } from "es-toolkit";
+import { z } from "zod";
+//#region src/vendors/telegram/contracts.ts
+const MAX_MEDIA_BYTES = 20 * 1024 * 1024;
+const telegramChatActionSchema = z.enum([
+	"typing",
+	"upload_photo",
+	"record_video",
+	"upload_video",
+	"record_voice",
+	"upload_voice",
+	"upload_document",
+	"choose_sticker",
+	"find_location",
+	"record_video_note",
+	"upload_video_note"
+]);
+const telegramAuthSchema = z.object({ bot_token: z.string().min(1).describe("Telegram bot token from BotFather") });
+const telegramSendTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id (string form of the numeric id)"),
+	text: z.string().min(1).max(4096).describe("Message text (max 4096 characters)"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional message id to reply to"),
+	reply_markup: z.unknown().optional().describe("Optional Telegram reply markup object")
+});
+const telegramMessageOutputSchema = z.object({
+	message_id: z.string().describe("Telegram message id as string"),
+	file_id: z.string().optional().describe("Telegram file_id when the message carries a document/photo/audio/video attachment")
+});
+const telegramEditTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	message_id: z.string().min(1).describe("Message id to edit"),
+	text: z.string().min(1).max(4096).describe("Replacement text (max 4096 characters)"),
+	reply_markup: z.unknown().optional().describe("Optional Telegram reply markup object")
+});
+const telegramSendChatActionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	action: telegramChatActionSchema.describe("Chat action shown to the user (typing, upload_photo, …)")
+});
+const telegramSetReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	message_id: z.string().min(1).describe("Message id to react to"),
+	emoji: z.string().min(1).max(32).describe("Any emoji reaction Telegram accepts for this bot/chat")
+});
+const telegramClearReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	message_id: z.string().min(1).describe("Message id to clear reactions on")
+});
+const telegramSendMediaInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	kind: z.enum(["photo", "document"]).describe("Media kind"),
+	body_base64: z.string().min(1).describe("File body as base64"),
+	file_name: z.string().min(1).describe("File name including extension"),
+	caption: z.string().max(1024).optional().describe("Optional caption (max 1024 characters)"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional message id to reply to"),
+	content_type: z.string().optional().describe("Optional content type for the upload")
+});
+const telegramDownloadFileInputSchema = z.object({
+	file_id: z.string().min(1).describe("Telegram file_id from an inbound attachment"),
+	file_name: z.string().min(1).optional().describe("Preferred file name for the download result")
+});
+const telegramDownloadFileOutputSchema = z.object({
+	file_name: z.string(),
+	file_size: z.number().optional(),
+	body_base64: z.string().describe("Downloaded file body as base64")
+});
+const telegramAnswerCallbackInputSchema = z.object({
+	callback_query_id: z.string().min(1).describe("callback_query.id from an inbound update"),
+	text: z.string().max(200).optional().describe("Optional notification text shown to the user"),
+	show_alert: z.boolean().optional().describe("When true, show an alert instead of a toast")
+});
+const telegramSendMediaGroupItemSchema = z.object({
+	kind: z.enum(["photo", "document"]).describe("Media kind; all items must be photo or all document"),
+	body_base64: z.string().min(1).describe("File body as base64"),
+	file_name: z.string().min(1).describe("File name including extension"),
+	caption: z.string().max(1024).optional().describe("Optional caption on this item"),
+	content_type: z.string().optional().describe("Optional content type")
+});
+const telegramSendMediaGroupInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Telegram chat id"),
+	items: z.array(telegramSendMediaGroupItemSchema).min(2).max(10).describe("2-10 media items; cannot mix photo and document"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional message id to reply to")
+});
+const telegramSendMediaGroupOutputSchema = z.object({ message_ids: z.array(z.string()).describe("Message ids for each media item") });
+const telegramGetBotOutputSchema = z.object({
+	bot_id: z.string(),
+	username: z.string(),
+	display_name: z.string()
+});
+const telegramOkOutputSchema = z.object({ ok: z.boolean() });
+//#endregion
+//#region src/vendors/telegram/domain.ts
+/**
+* Telegram payload shaping + envelope/result parse.
+* No HTTP — client owns transport.
+*/
+var TelegramClientError = class extends ToolError {
+	failureKind;
+	constructor(input) {
+		super(input.message, {
+			code: "upstream",
+			retryable: input.failureKind === "outcome_unknown",
+			cause: input.cause,
+			details: {
+				method: input.method,
+				failure_kind: input.failureKind,
+				status: input.status,
+				retry_after_seconds: input.retryAfterSeconds
+			}
+		});
+		this.name = "TelegramClientError";
+		this.failureKind = input.failureKind;
+	}
+};
+function isTelegramDefiniteRejection(error) {
+	return error instanceof TelegramClientError && error.failureKind === "definite_rejection";
+}
+function isTelegramOutcomeUnknown(error) {
+	return error instanceof TelegramClientError && error.failureKind === "outcome_unknown";
+}
+/** Network / abort / transport failures before a parseable Telegram envelope. */
+function throwTelegramTransportError(method, error) {
+	if (error instanceof TelegramClientError) throw error;
+	throw new TelegramClientError({
+		message: error instanceof Error ? error.message : `${method} request failed`,
+		failureKind: "outcome_unknown",
+		method,
+		cause: error
+	});
+}
+function isDefiniteStatus(status) {
+	return status === 400 || status === 401 || status === 403 || status === 404;
+}
+/** Map Telegram `{ ok, result | description }` (HTTP may be non-2xx). */
+function parseResult(label, status, data) {
+	if (!isPlainObject(data) || typeof data["ok"] !== "boolean") throw new TelegramClientError({
+		message: `${label} returned an invalid envelope`,
+		failureKind: "outcome_unknown",
+		method: label
+	});
+	if (status >= 200 && status < 300 && data["ok"] === true && data["result"] !== void 0) return data["result"];
+	const parameters = data["parameters"];
+	const retryAfter = isPlainObject(parameters) && typeof parameters["retry_after"] === "number" ? parameters["retry_after"] : void 0;
+	throw new TelegramClientError({
+		message: isString(data["description"]) ? data["description"] : `${label} failed`,
+		failureKind: isDefiniteStatus(status) ? "definite_rejection" : "outcome_unknown",
+		method: label,
+		status,
+		...retryAfter !== void 0 && { retryAfterSeconds: retryAfter }
+	});
+}
+/** Prefer largest photo size; else first of document/audio/video/voice/… with a file_id. */
+function extractTelegramFileId(message) {
+	const photo = message["photo"];
+	if (Array.isArray(photo) && photo.length > 0) {
+		let best;
+		let bestSize = -1;
+		for (const row of photo) {
+			if (!isPlainObject(row) || !isString(row["file_id"])) continue;
+			const size = typeof row["file_size"] === "number" ? row["file_size"] : 0;
+			if (size >= bestSize) {
+				bestSize = size;
+				best = row["file_id"];
+			}
+		}
+		if (best) return best;
+	}
+	for (const key of [
+		"document",
+		"audio",
+		"video",
+		"voice",
+		"video_note",
+		"animation",
+		"sticker"
+	]) {
+		const item = message[key];
+		if (isPlainObject(item) && isString(item["file_id"]) && item["file_id"].length > 0) return item["file_id"];
+	}
+}
+function parseMessage(value) {
+	if (!isPlainObject(value) || typeof value["message_id"] !== "number") throw new ToolError("Telegram returned an invalid message", { code: "upstream" });
+	const fileId = extractTelegramFileId(value);
+	return {
+		message_id: String(value["message_id"]),
+		...fileId && { file_id: fileId }
+	};
+}
+function parseMessages(value) {
+	if (!Array.isArray(value)) throw new ToolError("Telegram returned an invalid message list", { code: "upstream" });
+	return { message_ids: value.map((row) => parseMessage(row).message_id) };
+}
+function parseOk(value) {
+	if (value !== true) throw new ToolError("Telegram returned unexpected result", { code: "upstream" });
+}
+function parseBot(value) {
+	if (!isPlainObject(value) || typeof value["id"] !== "number" || !isString(value["username"]) || !isString(value["first_name"])) throw new ToolError("Telegram getMe returned invalid bot identity", { code: "upstream" });
+	return {
+		bot_id: String(value["id"]),
+		username: value["username"],
+		display_name: value["first_name"]
+	};
+}
+function parseFile(value) {
+	if (!isPlainObject(value) || !isString(value["file_path"])) throw new ToolError("Telegram getFile returned invalid payload", { code: "upstream" });
+	return {
+		file_path: value["file_path"],
+		...typeof value["file_size"] === "number" && { file_size: value["file_size"] }
+	};
+}
+function parseDownload(input, file, bytes) {
+	return {
+		file_name: input.file_name ?? file.file_path.split("/").pop() ?? input.file_id,
+		...file.file_size !== void 0 && { file_size: file.file_size },
+		body_base64: bytesToBase64(bytes)
+	};
+}
+function decodeMedia(bodyBase64) {
+	let bytes;
+	try {
+		bytes = base64ToBytes(bodyBase64);
+	} catch (error) {
+		throw new ToolError("Invalid base64 body", {
+			code: "bad_input",
+			cause: error
+		});
+	}
+	if (bytes.byteLength === 0) throw new ToolError("Media body must not be empty", { code: "bad_input" });
+	if (bytes.byteLength > 20971520) throw new ToolError("Media exceeds 20 MiB limit", {
+		code: "too_large",
+		details: {
+			max_bytes: MAX_MEDIA_BYTES,
+			content_length: bytes.byteLength
+		}
+	});
+	return bytes;
+}
+function blob(bytes, contentType) {
+	return contentType ? new Blob([toArrayBuffer(bytes)], { type: contentType }) : new Blob([toArrayBuffer(bytes)]);
+}
+/** Multipart body for sendPhoto / sendDocument. */
+function buildMediaForm(input) {
+	const bytes = decodeMedia(input.body_base64);
+	const form = new FormData();
+	form.set("chat_id", input.chat_id);
+	form.set(input.kind === "photo" ? "photo" : "document", blob(bytes, input.content_type), input.file_name);
+	if (input.caption) form.set("caption", input.caption);
+	if (input.reply_to_message_id) form.set("reply_parameters", JSON.stringify({ message_id: Number.parseInt(input.reply_to_message_id, 10) }));
+	return form;
+}
+/** Multipart body for sendMediaGroup. */
+function buildMediaGroupForm(input) {
+	if (input.items.length < 2 || input.items.length > 10) throw new ToolError("Media groups require between 2 and 10 items", { code: "bad_input" });
+	const hasDoc = input.items.some((item) => item.kind === "document");
+	const hasPhoto = input.items.some((item) => item.kind === "photo");
+	if (hasDoc && hasPhoto) throw new ToolError("Media groups cannot mix photo and document items", { code: "bad_input" });
+	const form = new FormData();
+	form.set("chat_id", input.chat_id);
+	if (input.reply_to_message_id) form.set("reply_parameters", JSON.stringify({ message_id: Number.parseInt(input.reply_to_message_id, 10) }));
+	const media = input.items.map((item, index) => {
+		const bytes = decodeMedia(item.body_base64);
+		form.set(`file${index}`, blob(bytes, item.content_type), item.file_name);
+		return {
+			type: item.kind,
+			media: `attach://file${index}`,
+			...item.caption && { caption: item.caption }
+		};
+	});
+	form.set("media", JSON.stringify(media));
+	return form;
+}
+//#endregion
+//#region src/vendors/telegram/client.ts
+/**
+* Telegram Bot API vendor client.
+* Host: `new TelegramClient(auth)`. Agent tools: `fromContext(ctx)`.
+*/
+var TelegramClient = class TelegramClient {
+	#token;
+	#http;
+	constructor(auth, options = {}) {
+		const parsed = telegramAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid Telegram auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#token = parsed.data.bot_token;
+		this.#http = new HttpService({
+			...options,
+			baseURL: "https://api.telegram.org",
+			label: "Telegram"
+		});
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, telegramAuthSchema);
+		return new TelegramClient(auth, {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	async #post(path, body, label) {
+		try {
+			const res = await this.#http.post(path, body, {
+				label,
+				noThrow: true
+			});
+			return parseResult(label, res.status, res.data);
+		} catch (error) {
+			throwTelegramTransportError(label, error);
+		}
+	}
+	/** POST /bot{token}/sendMessage */
+	async sendText(input) {
+		const body = {
+			chat_id: input.chat_id,
+			text: input.text,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup },
+			...input.reply_to_message_id && { reply_parameters: { message_id: Number.parseInt(input.reply_to_message_id, 10) } }
+		};
+		return parseMessage(await this.#post(`/bot${this.#token}/sendMessage`, body, "Telegram sendMessage"));
+	}
+	/** POST /bot{token}/editMessageText */
+	async editText(input) {
+		const body = {
+			chat_id: input.chat_id,
+			message_id: Number.parseInt(input.message_id, 10),
+			text: input.text,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		};
+		return parseMessage(await this.#post(`/bot${this.#token}/editMessageText`, body, "Telegram editMessageText"));
+	}
+	/** POST /bot{token}/sendChatAction */
+	async sendChatAction(input) {
+		parseOk(await this.#post(`/bot${this.#token}/sendChatAction`, {
+			chat_id: input.chat_id,
+			action: input.action
+		}, "Telegram sendChatAction"));
+	}
+	/** POST /bot{token}/setMessageReaction */
+	async setReaction(input) {
+		parseOk(await this.#post(`/bot${this.#token}/setMessageReaction`, {
+			chat_id: input.chat_id,
+			message_id: Number.parseInt(input.message_id, 10),
+			reaction: [{
+				type: "emoji",
+				emoji: input.emoji
+			}]
+		}, "Telegram setMessageReaction"));
+	}
+	/** POST /bot{token}/setMessageReaction (empty reaction) */
+	async clearReaction(input) {
+		parseOk(await this.#post(`/bot${this.#token}/setMessageReaction`, {
+			chat_id: input.chat_id,
+			message_id: Number.parseInt(input.message_id, 10),
+			reaction: []
+		}, "Telegram setMessageReaction"));
+	}
+	/** POST /bot{token}/sendPhoto | sendDocument */
+	async sendMedia(input) {
+		const path = input.kind === "photo" ? `/bot${this.#token}/sendPhoto` : `/bot${this.#token}/sendDocument`;
+		const label = input.kind === "photo" ? "Telegram sendPhoto" : "Telegram sendDocument";
+		return parseMessage(await this.#post(path, buildMediaForm(input), label));
+	}
+	/** POST /bot{token}/sendMediaGroup */
+	async sendMediaGroup(input) {
+		return parseMessages(await this.#post(`/bot${this.#token}/sendMediaGroup`, buildMediaGroupForm(input), "Telegram sendMediaGroup"));
+	}
+	/** POST getFile + GET /file/bot{token}/{file_path} */
+	async downloadFile(input) {
+		const file = parseFile(await this.#post(`/bot${this.#token}/getFile`, { file_id: input.file_id }, "Telegram getFile"));
+		const filePath = file.file_path.replace(/^\/+/, "");
+		let res;
+		try {
+			res = await this.#http.bytes("GET", `/file/bot${this.#token}/${filePath}`, {
+				label: "Telegram downloadFile",
+				noThrow: true
+			});
+		} catch (error) {
+			throwTelegramTransportError("Telegram downloadFile", error);
+		}
+		if (!res.ok) throw new TelegramClientError({
+			message: `Telegram downloadFile failed with HTTP ${res.status}`,
+			failureKind: res.status === 400 || res.status === 401 || res.status === 403 || res.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Telegram downloadFile",
+			status: res.status
+		});
+		return parseDownload(input, file, res.bytes);
+	}
+	/** POST /bot{token}/answerCallbackQuery */
+	async answerCallback(input) {
+		const body = {
+			callback_query_id: input.callback_query_id,
+			...input.text && { text: input.text },
+			...input.show_alert !== void 0 && { show_alert: input.show_alert }
+		};
+		parseOk(await this.#post(`/bot${this.#token}/answerCallbackQuery`, body, "Telegram answerCallbackQuery"));
+	}
+	/** POST /bot{token}/getMe */
+	async getBot() {
+		return parseBot(await this.#post(`/bot${this.#token}/getMe`, {}, "Telegram getMe"));
+	}
+	/** POST /bot{token}/getWebhookInfo */
+	async getWebhookInfo() {
+		const value = await this.#post(`/bot${this.#token}/getWebhookInfo`, {}, "Telegram getWebhookInfo");
+		if (!isPlainObject(value) || !isString(value["url"]) || typeof value["pending_update_count"] !== "number") throw new ToolError("Telegram getWebhookInfo returned invalid payload", { code: "upstream" });
+		return {
+			url: value["url"],
+			pending_update_count: value["pending_update_count"],
+			...typeof value["last_error_date"] === "number" && { last_error_at_unix: value["last_error_date"] },
+			...isString(value["last_error_message"]) && { last_error_message: value["last_error_message"] }
+		};
+	}
+	/** POST /bot{token}/setWebhook */
+	async setWebhook(input) {
+		parseOk(await this.#post(`/bot${this.#token}/setWebhook`, {
+			url: input.url,
+			secret_token: input.secret_token,
+			allowed_updates: input.allowed_updates ?? ["message", "callback_query"]
+		}, "Telegram setWebhook"));
+	}
+	/** POST /bot{token}/deleteWebhook */
+	async deleteWebhook(input) {
+		parseOk(await this.#post(`/bot${this.#token}/deleteWebhook`, { drop_pending_updates: input?.drop_pending_updates ?? false }, "Telegram deleteWebhook"));
+	}
+};
+//#endregion
+//#region src/vendors/telegram/module.ts
+const emptyInputSchema = z.object({}).describe("No input fields");
+const telegramSendTextTool = defineTool({
+	id: "telegram-send-text",
+	name: "telegramSendText",
+	description: "Send a text message to a Telegram chat. Optional reply_to_message_id anchors a native reply. Returns the new message_id.",
+	inputSchema: telegramSendTextInputSchema,
+	outputSchema: telegramMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => TelegramClient.fromContext(ctx).sendText(input)
+});
+const telegramEditTextTool = defineTool({
+	id: "telegram-edit-text",
+	name: "telegramEditText",
+	description: "Edit the text of an existing Telegram message. Used for progressive live updates and corrections.",
+	inputSchema: telegramEditTextInputSchema,
+	outputSchema: telegramMessageOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => TelegramClient.fromContext(ctx).editText(input)
+});
+const telegramSendChatActionTool = defineTool({
+	id: "telegram-send-chat-action",
+	name: "telegramSendChatAction",
+	description: "Show a chat action to the user (typing, upload_photo, upload_document, and other Telegram actions). Renew while work is in progress.",
+	inputSchema: telegramSendChatActionInputSchema,
+	outputSchema: telegramOkOutputSchema,
+	sideEffect: "none",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TelegramClient.fromContext(ctx).sendChatAction(input);
+		return { ok: true };
+	}
+});
+const telegramSetReactionTool = defineTool({
+	id: "telegram-set-reaction",
+	name: "telegramSetReaction",
+	description: "Set an emoji reaction on a Telegram message. Any emoji Telegram accepts for the bot and chat is allowed.",
+	inputSchema: telegramSetReactionInputSchema,
+	outputSchema: telegramOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TelegramClient.fromContext(ctx).setReaction(input);
+		return { ok: true };
+	}
+});
+const telegramClearReactionTool = defineTool({
+	id: "telegram-clear-reaction",
+	name: "telegramClearReaction",
+	description: "Clear all bot reactions on a Telegram message.",
+	inputSchema: telegramClearReactionInputSchema,
+	outputSchema: telegramOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TelegramClient.fromContext(ctx).clearReaction(input);
+		return { ok: true };
+	}
+});
+const telegramSendMediaTool = defineTool({
+	id: "telegram-send-media",
+	name: "telegramSendMedia",
+	description: "Send one photo or document to a Telegram chat from a base64 body. For multiple related files use telegram-send-media-group.",
+	inputSchema: telegramSendMediaInputSchema,
+	outputSchema: telegramMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => TelegramClient.fromContext(ctx).sendMedia(input)
+});
+const telegramSendMediaGroupTool = defineTool({
+	id: "telegram-send-media-group",
+	name: "telegramSendMediaGroup",
+	description: "Send 2-10 photos or 2-10 documents as one Telegram media group. Cannot mix photo and document items.",
+	inputSchema: telegramSendMediaGroupInputSchema,
+	outputSchema: telegramSendMediaGroupOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => TelegramClient.fromContext(ctx).sendMediaGroup(input)
+});
+const telegramDownloadFileTool = defineTool({
+	id: "telegram-download-file",
+	name: "telegramDownloadFile",
+	description: "Download a Telegram file by file_id and return the body as base64 with optional size and name.",
+	inputSchema: telegramDownloadFileInputSchema,
+	outputSchema: telegramDownloadFileOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => TelegramClient.fromContext(ctx).downloadFile(input)
+});
+const telegramAnswerCallbackTool = defineTool({
+	id: "telegram-answer-callback",
+	name: "telegramAnswerCallback",
+	description: "Acknowledge a Telegram callback query. Optional text shows a toast or alert to the user.",
+	inputSchema: telegramAnswerCallbackInputSchema,
+	outputSchema: telegramOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TelegramClient.fromContext(ctx).answerCallback(input);
+		return { ok: true };
+	}
+});
+const telegramGetBotTool = defineTool({
+	id: "telegram-get-bot",
+	name: "telegramGetBot",
+	description: "Return the active Telegram bot identity, including bot_id, username, and display_name.",
+	inputSchema: emptyInputSchema,
+	outputSchema: telegramGetBotOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (_input, ctx) => TelegramClient.fromContext(ctx).getBot()
+});
+const telegramModule = defineModule({
+	id: "telegram",
+	title: "Telegram",
+	description: "Telegram Bot API tools for text, media, media groups, chat actions, reactions, file download, callbacks, and bot identity.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: telegramAuthSchema
+	},
+	categories: ["messaging", "chat"],
+	classification: "pii",
+	tags: ["telegram"],
+	tools: [
+		telegramSendTextTool,
+		telegramEditTextTool,
+		telegramSendChatActionTool,
+		telegramSetReactionTool,
+		telegramClearReactionTool,
+		telegramSendMediaTool,
+		telegramSendMediaGroupTool,
+		telegramDownloadFileTool,
+		telegramAnswerCallbackTool,
+		telegramGetBotTool
+	]
+});
+//#endregion
+//#region src/vendors/telegram/webhook.ts
+/**
+* Verify Telegram webhook secret header (x-telegram-bot-api-secret-token).
+* Exact string match; constant-time comparison when lengths match.
+*/
+function verifyTelegramWebhookSecret(headerValue, expectedSecret) {
+	if (!headerValue) return false;
+	if (expectedSecret.length === 0) return false;
+	if (headerValue.length !== expectedSecret.length) return false;
+	let mismatch = 0;
+	for (let i = 0; i < headerValue.length; i += 1) mismatch |= headerValue.charCodeAt(i) ^ expectedSecret.charCodeAt(i);
+	return mismatch === 0;
+}
+/**
+* Parse one raw Bot API Update into a normalized inbound event.
+* Returns ok:false for updates the pack does not surface (unsupported chat types, empty noise).
+*/
+function parseTelegramUpdate(update, options) {
+	if (!isPlainObject(update)) return {
+		ok: false,
+		reason: "update_not_object"
+	};
+	const updateId = update["update_id"];
+	if (typeof updateId !== "number") return {
+		ok: false,
+		reason: "missing_update_id"
+	};
+	const receivedAt = options?.received_at ?? (/* @__PURE__ */ new Date()).toISOString();
+	const allowGroups = options?.allow_group_chats ?? false;
+	const message = asMessage(update["message"]) ?? asMessage(update["edited_message"]);
+	if (message) return parseMessageUpdate(updateId, message, receivedAt, allowGroups, Boolean(update["edited_message"]));
+	const callback = update["callback_query"];
+	if (isPlainObject(callback)) return parseCallbackUpdate(updateId, callback, receivedAt, allowGroups);
+	return {
+		ok: false,
+		reason: "unsupported_update_type"
+	};
+}
+function parseMessageUpdate(updateId, message, receivedAt, allowGroups, edited) {
+	const chat = message["chat"];
+	if (!isPlainObject(chat) || typeof chat["id"] !== "number") return {
+		ok: false,
+		reason: "missing_chat"
+	};
+	const chatType = isString(chat["type"]) ? chat["type"] : void 0;
+	if (!allowGroups && chatType && chatType !== "private") return {
+		ok: false,
+		reason: "non_private_chat"
+	};
+	const from = message["from"];
+	const userId = isPlainObject(from) && typeof from["id"] === "number" ? String(from["id"]) : void 0;
+	const username = isPlainObject(from) && isString(from["username"]) ? from["username"] : void 0;
+	const messageId = typeof message["message_id"] === "number" ? String(message["message_id"]) : void 0;
+	const text = firstString(message["text"], message["caption"]);
+	const media = collectMedia(message);
+	const replyTo = isPlainObject(message["reply_to_message"]) && typeof message["reply_to_message"]["message_id"] === "number" ? String(message["reply_to_message"]["message_id"]) : void 0;
+	const mediaGroupId = isString(message["media_group_id"]) ? message["media_group_id"] : void 0;
+	if (!text && media.length === 0) return {
+		ok: false,
+		reason: "empty_message"
+	};
+	return {
+		ok: true,
+		event: {
+			channel: "telegram",
+			event_id: String(updateId),
+			chat_id: String(chat["id"]),
+			raw_type: edited ? "edited_message" : "message",
+			received_at: receivedAt,
+			...userId && { user_id: userId },
+			...username && { username },
+			...messageId && { message_id: messageId },
+			...text && { text },
+			...media.length > 0 && { media },
+			...replyTo && { reply_to: replyTo },
+			...mediaGroupId && { media_group_id: mediaGroupId },
+			...chatType && { chat_type: chatType }
+		}
+	};
+}
+function parseCallbackUpdate(updateId, callback, receivedAt, allowGroups) {
+	const message = asMessage(callback["message"]);
+	const chat = message ? message["chat"] : void 0;
+	if (!isPlainObject(chat) || typeof chat["id"] !== "number") return {
+		ok: false,
+		reason: "callback_missing_chat"
+	};
+	const chatType = isString(chat["type"]) ? chat["type"] : void 0;
+	if (!allowGroups && chatType && chatType !== "private") return {
+		ok: false,
+		reason: "non_private_chat"
+	};
+	const from = callback["from"];
+	const userId = isPlainObject(from) && typeof from["id"] === "number" ? String(from["id"]) : void 0;
+	const username = isPlainObject(from) && isString(from["username"]) ? from["username"] : void 0;
+	const callbackQueryId = isString(callback["id"]) ? callback["id"] : void 0;
+	if (!callbackQueryId) return {
+		ok: false,
+		reason: "callback_missing_id"
+	};
+	const callbackData = isString(callback["data"]) ? callback["data"] : void 0;
+	const messageId = message && typeof message["message_id"] === "number" ? String(message["message_id"]) : void 0;
+	return {
+		ok: true,
+		event: {
+			channel: "telegram",
+			event_id: String(updateId),
+			chat_id: String(chat["id"]),
+			raw_type: "callback_query",
+			received_at: receivedAt,
+			callback_query_id: callbackQueryId,
+			...userId && { user_id: userId },
+			...username && { username },
+			...messageId && { message_id: messageId },
+			...callbackData && { callback_data: callbackData },
+			...chatType && { chat_type: chatType }
+		}
+	};
+}
+function asMessage(value) {
+	return isPlainObject(value) ? value : void 0;
+}
+function firstString(...values) {
+	for (const value of values) if (isString(value) && value.length > 0) return value;
+}
+function collectMedia(message) {
+	const out = [];
+	const photo = message["photo"];
+	if (Array.isArray(photo) && photo.length > 0) {
+		const largest = photo[photo.length - 1];
+		if (isPlainObject(largest) && isString(largest["file_id"])) out.push({
+			kind: "photo",
+			ref: largest["file_id"],
+			...isString(largest["file_unique_id"]) ? { unique_ref: largest["file_unique_id"] } : {},
+			...typeof largest["file_size"] === "number" ? { file_size: largest["file_size"] } : {},
+			media_type: "image/jpeg"
+		});
+	}
+	for (const key of [
+		"document",
+		"audio",
+		"video",
+		"voice",
+		"video_note",
+		"animation",
+		"sticker"
+	]) {
+		const item = message[key];
+		if (!isPlainObject(item) || !isString(item["file_id"])) continue;
+		out.push({
+			kind: key,
+			ref: item["file_id"],
+			...isString(item["file_unique_id"]) ? { unique_ref: item["file_unique_id"] } : {},
+			...typeof item["file_size"] === "number" ? { file_size: item["file_size"] } : {},
+			...isString(item["file_name"]) ? { file_name: item["file_name"] } : {},
+			...isString(item["mime_type"]) ? { media_type: item["mime_type"] } : {}
+		});
+	}
+	return out;
+}
+//#endregion
+export { telegramSendMediaGroupOutputSchema as A, telegramDownloadFileOutputSchema as C, telegramOkOutputSchema as D, telegramMessageOutputSchema as E, telegramSendTextInputSchema as M, telegramSetReactionInputSchema as N, telegramSendChatActionInputSchema as O, telegramDownloadFileInputSchema as S, telegramGetBotOutputSchema as T, isTelegramOutcomeUnknown as _, telegramDownloadFileTool as a, telegramAuthSchema as b, telegramModule as c, telegramSendMediaTool as d, telegramSendTextTool as f, isTelegramDefiniteRejection as g, TelegramClientError as h, telegramClearReactionTool as i, telegramSendMediaInputSchema as j, telegramSendMediaGroupInputSchema as k, telegramSendChatActionTool as l, TelegramClient as m, verifyTelegramWebhookSecret as n, telegramEditTextTool as o, telegramSetReactionTool as p, telegramAnswerCallbackTool as r, telegramGetBotTool as s, parseTelegramUpdate as t, telegramSendMediaGroupTool as u, MAX_MEDIA_BYTES as v, telegramEditTextInputSchema as w, telegramClearReactionInputSchema as x, telegramAnswerCallbackInputSchema as y };
+
+//# sourceMappingURL=telegram-DDXWzkfL.js.map