jeo-code 0.12.7 → 0.12.8

package/src/messenger/session-pool.ts

@@ -0,0 +1,109 @@
+import type { MessengerActivityReporter } from "./types";
+
+interface WorkerProcess {
+	stdin: { write(data: string): unknown; flush(): unknown; end(): unknown };
+	stdout: ReadableStream<Uint8Array>;
+	stderr: ReadableStream<Uint8Array>;
+	exited: Promise<number>;
+	kill(): void;
+}
+
+interface Pending {
+	resolve(text: string): void;
+	reject(error: Error): void;
+	report?: MessengerActivityReporter;
+}
+
+interface Worker {
+	child: WorkerProcess;
+	pending?: Pending;
+	lastUsed: number;
+	dead: boolean;
+}
+
+export function createMessengerSessionPool(spawn: typeof Bun.spawn = Bun.spawn, limit = 16) {
+	const workers = new Map<string, Worker>();
+	let closed = false;
+	let tick = 0;
+
+	function retire(key: string, worker: Worker) {
+		if (worker.dead) return;
+		worker.dead = true;
+		if (workers.get(key) === worker) workers.delete(key);
+		worker.pending?.reject(new Error("Messenger worker stopped"));
+		worker.pending = undefined;
+		worker.child.kill();
+	}
+
+	async function readLines(stream: ReadableStream<Uint8Array>, handle: (line: string) => void) {
+		const reader = stream.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		try {
+			while (true) {
+				const chunk = await reader.read();
+				if (chunk.done) break;
+				buffer += decoder.decode(chunk.value, { stream: true });
+				if (buffer.length > 1_000_000) throw new Error("Messenger worker output too large");
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+				for (const line of lines) handle(line);
+			}
+		} finally { reader.releaseLock(); }
+	}
+
+	function start(key: string, command: string[], cwd: string, env: Record<string, string>): Worker {
+		if (workers.size >= limit) {
+			const idle = [...workers.entries()].filter(([, worker]) => !worker.pending).sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
+			if (!idle) throw new Error("Messenger worker capacity reached");
+			retire(idle[0], idle[1]);
+		}
+		const child = spawn(command, { cwd, env, stdin: "pipe", stdout: "pipe", stderr: "pipe" }) as unknown as WorkerProcess;
+		const worker: Worker = { child, lastUsed: ++tick, dead: false };
+		workers.set(key, worker);
+		void readLines(child.stdout, line => {
+			const pending = worker.pending;
+			if (!pending) return;
+			if (line === "JEO_MESSENGER_ERROR") { retire(key, worker); return; }
+			if (!line.startsWith("JEO_MESSENGER_RESULT ")) return;
+			try {
+				const text: unknown = JSON.parse(line.slice("JEO_MESSENGER_RESULT ".length));
+				if (typeof text !== "string" || !text.trim()) throw new Error("Invalid response");
+				worker.pending = undefined;
+				worker.lastUsed = ++tick;
+				pending.resolve(text);
+			} catch { retire(key, worker); }
+		}).catch(() => retire(key, worker));
+		void readLines(child.stderr, line => {
+			if (line === "JEO_MESSENGER_STEP") worker.pending?.report?.("Working on your request");
+		}).catch(() => retire(key, worker));
+		void child.exited.then(() => retire(key, worker), () => retire(key, worker));
+		return worker;
+	}
+
+	async function turn(key: string, command: string[], cwd: string, env: Record<string, string>, text: string, signal: AbortSignal, report?: MessengerActivityReporter): Promise<string> {
+		if (closed || signal.aborted) throw new Error("Messenger request aborted");
+		const worker = workers.get(key) ?? start(key, command, cwd, env);
+		if (worker.pending) throw new Error("Messenger conversation is already active");
+		return await new Promise<string>((resolve, reject) => {
+			const abort = () => retire(key, worker);
+			const cleanup = () => signal.removeEventListener("abort", abort);
+			worker.pending = { resolve: value => { cleanup(); resolve(value); }, reject: error => { cleanup(); reject(error); }, report };
+			signal.addEventListener("abort", abort, { once: true });
+			if (signal.aborted) { abort(); return; }
+			void (async () => {
+				await worker.child.stdin.write(`${JSON.stringify(text)}\n`);
+				if (!worker.dead) await worker.child.stdin.flush();
+			})().catch(() => retire(key, worker));
+		});
+	}
+
+	async function close() {
+		closed = true;
+		const all = [...workers.entries()];
+		for (const [key, worker] of all) retire(key, worker);
+		await Promise.allSettled(all.map(([, worker]) => worker.child.exited));
+	}
+
+	return { turn, close };
+}

package/src/messenger/slack.ts

@@ -0,0 +1,333 @@
+import { resolveMessengerToken } from "./config";
+import { MessengerHttpError, messengerFetchJson, splitMessengerText, waitForMessengerRetry } from "./http";
+import type { MessengerAdapter, MessengerMessage, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+
+const BACKOFF_BASE_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+const CONNECT_TIMEOUT_MS = 15_000;
+const MAX_RECENT_MESSAGES = 2_000;
+const PERMANENT_ERRORS: Record<string, true> = {
+	invalid_auth: true,
+	not_authed: true,
+	account_inactive: true,
+	token_expired: true,
+	token_revoked: true,
+	missing_scope: true,
+	missing_args: true,
+	not_allowed_token_type: true,
+	no_permission: true,
+	access_denied: true,
+	accesslimited: true,
+	forbidden_team: true,
+	team_access_not_granted: true,
+	enterprise_is_restricted: true,
+	two_factor_setup_required: true,
+};
+
+class SlackConfigurationError extends Error {}
+
+function object(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function requiredToken(value: string | undefined, prefix: string): string {
+	if (!value?.startsWith(prefix) || value.length === prefix.length || /\s/.test(value)) {
+		throw new SlackConfigurationError("Slack token configuration is invalid");
+	}
+	return value;
+}
+
+async function slackRequest(
+	method: "auth.test" | "apps.connections.open" | "chat.postMessage",
+	token: string,
+	body: Record<string, unknown>,
+	signal?: AbortSignal,
+	fetchImpl?: typeof fetch,
+): Promise<Record<string, unknown>> {
+	let response: unknown;
+	try {
+		response = await messengerFetchJson(
+			`https://slack.com/api/${method}`,
+			{
+				method: "POST",
+				headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+				body: JSON.stringify(body),
+			},
+			signal,
+			fetchImpl,
+		);
+	} catch (error) {
+		if (error instanceof MessengerHttpError && error.status === 429) throw error;
+		if (error instanceof MessengerHttpError && (error.status === 401 || error.status === 403)) {
+			throw new SlackConfigurationError("Slack authentication or permission failed");
+		}
+		throw new Error("Slack API request failed");
+	}
+	const data = object(response);
+	if (data?.ok !== true) {
+		if (typeof data?.error === "string" && Object.hasOwn(PERMANENT_ERRORS, data.error)) {
+			throw new SlackConfigurationError("Slack authentication or permission failed");
+		}
+		throw new Error("Slack API request failed");
+	}
+	return data;
+}
+
+function socketUrl(value: unknown): string {
+	let url: URL;
+	try {
+		if (typeof value !== "string") throw new Error();
+		url = new URL(value);
+	} catch {
+		throw new SlackConfigurationError("Slack returned an invalid Socket Mode endpoint");
+	}
+	if (
+		url.protocol !== "wss:" ||
+		!(url.hostname === "slack.com" || url.hostname.endsWith(".slack.com")) ||
+		(url.port !== "" && url.port !== "443") ||
+		url.username ||
+		url.password ||
+		url.hash
+	) {
+		throw new SlackConfigurationError("Slack returned an invalid Socket Mode endpoint");
+	}
+	return url.href;
+}
+
+function messageFromEnvelope(
+	envelope: Record<string, unknown>,
+	teamId: string,
+	botUserId: string,
+): MessengerMessage | undefined {
+	if (envelope.type !== "events_api") return undefined;
+	const payload = object(envelope.payload);
+	if (payload?.team_id !== teamId) return undefined;
+	const event = object(payload.event);
+	if (
+		!event ||
+		(event.type !== "message" && event.type !== "app_mention") ||
+		event.bot_id !== undefined ||
+		event.bot_profile !== undefined ||
+		event.subtype !== undefined ||
+		event.edited !== undefined ||
+		event.hidden === true ||
+		typeof event.user !== "string" ||
+		!event.user ||
+		event.user === botUserId ||
+		typeof event.channel !== "string" ||
+		!event.channel ||
+		typeof event.ts !== "string" ||
+		!event.ts ||
+		typeof event.text !== "string"
+	) {
+		return undefined;
+	}
+	let mentioned = false;
+	const text = event.text
+		.replace(/<@([A-Z0-9]+)(?:\|[^>]+)?>/g, (mention: string, user: string) => {
+			if (user !== botUserId) return mention;
+			mentioned = true;
+			return "";
+		})
+		.trim();
+	const direct = event.channel_type === "im" || (event.channel_type === undefined && event.channel.startsWith("D"));
+	const threadId =
+		typeof event.thread_ts === "string" && event.thread_ts ? event.thread_ts : direct ? undefined : event.ts;
+	return {
+		platform: "slack",
+		accountId: teamId,
+		channelId: event.channel,
+		senderId: event.user,
+		messageId: event.ts,
+		text,
+		threadId,
+		direct,
+		mentioned,
+	};
+}
+
+async function receiveSocket(
+	url: string,
+	teamId: string,
+	botUserId: string,
+	recent: Set<string>,
+	onMessage: (message: MessengerMessage) => Promise<void>,
+	signal: AbortSignal,
+	Socket: typeof WebSocket,
+): Promise<void> {
+	if (signal.aborted) return;
+	let socket: WebSocket;
+	try {
+		socket = new Socket(url);
+	} catch {
+		throw new Error("Slack Socket Mode connection failed");
+	}
+	const completion = Promise.withResolvers<void>();
+	let settled = false;
+	const timer = setTimeout(() => finish(), CONNECT_TIMEOUT_MS);
+	function finish(error?: SlackConfigurationError): void {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		signal.removeEventListener("abort", stop);
+		socket.removeEventListener("message", message);
+		socket.removeEventListener("close", stop);
+		socket.removeEventListener("error", stop);
+		try {
+			socket.close();
+		} catch {
+			/* ignore close error */
+		}
+		if (error) completion.reject(error);
+		else completion.resolve();
+	}
+	function stop(): void {
+		finish();
+	}
+	function message(incoming: MessageEvent): void {
+		if (settled || signal.aborted || typeof incoming.data !== "string") return;
+		let envelope: Record<string, unknown> | undefined;
+		try {
+			envelope = object(JSON.parse(incoming.data));
+		} catch {
+			return;
+		}
+		if (!envelope) return;
+		if (typeof envelope.envelope_id === "string") {
+			try {
+				socket.send(JSON.stringify({ envelope_id: envelope.envelope_id }));
+			} catch {
+				finish();
+				return;
+			}
+		}
+		if (envelope.type === "hello") {
+			clearTimeout(timer);
+			return;
+		}
+		if (envelope.type === "disconnect") {
+			finish(
+				envelope.reason === "link_disabled"
+					? new SlackConfigurationError("Slack Socket Mode is disabled")
+					: undefined,
+			);
+			return;
+		}
+		const parsed = messageFromEnvelope(envelope, teamId, botUserId);
+		if (!parsed) return;
+		const key = JSON.stringify([parsed.accountId, parsed.channelId, parsed.messageId]);
+		if (recent.has(key)) return;
+		recent.add(key);
+		if (recent.size > MAX_RECENT_MESSAGES) {
+			const oldest = recent.values().next().value;
+			if (oldest !== undefined) recent.delete(oldest);
+		}
+		void Promise.resolve()
+			.then(() => {
+				if (!signal.aborted) return onMessage(parsed);
+			})
+			.catch(() => {});
+	}
+	socket.addEventListener("message", message);
+	socket.addEventListener("close", stop);
+	socket.addEventListener("error", stop);
+	signal.addEventListener("abort", stop, { once: true });
+	if (signal.aborted) finish();
+	await completion.promise;
+}
+
+export function createSlackAdapter(
+	config: MessengerPlatformConfig,
+	env: Record<string, string | undefined> = process.env,
+	deps: MessengerTransportDeps = {},
+): MessengerAdapter {
+	let teamId: string | undefined;
+	let running = false;
+	return {
+		platform: "slack",
+		async start(onMessage, signal) {
+			if (signal.aborted) return;
+			if (running) throw new SlackConfigurationError("Slack adapter is already running");
+			const botToken = requiredToken(resolveMessengerToken(config.tokenEnv, env), "xoxb-");
+			const appToken = requiredToken(
+				resolveMessengerToken(config.appTokenEnv ?? "JEO_SLACK_APP_TOKEN", env),
+				"xapp-",
+			);
+			const recent = new Set<string>();
+			let botUserId: string | undefined;
+			let backoff = BACKOFF_BASE_MS;
+			running = true;
+			try {
+				while (!signal.aborted) {
+					const startedAt = Date.now();
+					let retryAfterMs = 0;
+					try {
+						if (!botUserId || !teamId) {
+							const identity = await slackRequest("auth.test", botToken, {}, signal, deps.fetch);
+							if (
+								typeof identity.team_id !== "string" ||
+								!identity.team_id ||
+								typeof identity.user_id !== "string" ||
+								!identity.user_id
+							) {
+								throw new SlackConfigurationError("Slack returned an invalid bot identity");
+							}
+							teamId = identity.team_id;
+							botUserId = identity.user_id;
+						}
+						const connection = await slackRequest("apps.connections.open", appToken, {}, signal, deps.fetch);
+						await receiveSocket(
+							socketUrl(connection.url),
+							teamId,
+							botUserId,
+							recent,
+							onMessage,
+							signal,
+							deps.WebSocket ?? WebSocket,
+						);
+					} catch (error) {
+						if (signal.aborted) break;
+						if (error instanceof SlackConfigurationError) throw error;
+						if (error instanceof MessengerHttpError) retryAfterMs = error.retryAfterMs ?? 0;
+					}
+					if (signal.aborted) break;
+					if (Date.now() - startedAt >= BACKOFF_MAX_MS) backoff = BACKOFF_BASE_MS;
+					await waitForMessengerRetry(Math.max(backoff, retryAfterMs), signal);
+					backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+				}
+			} finally {
+				running = false;
+			}
+		},
+		async send(message, text, signal) {
+			if (message.platform !== "slack" || (teamId !== undefined && message.accountId !== teamId)) {
+				throw new SlackConfigurationError("Slack reply account does not match");
+			}
+			const token = requiredToken(resolveMessengerToken(config.tokenEnv, env), "xoxb-");
+			const chunks = splitMessengerText(text, 4_000);
+			const sendSignal = signal ?? new AbortController().signal;
+			for (const [index, chunk] of chunks.entries()) {
+				if (index > 0) await waitForMessengerRetry(1_000, sendSignal);
+				if (sendSignal.aborted) throw new Error("Slack send cancelled");
+				await slackRequest(
+					"chat.postMessage",
+					token,
+					{
+						channel: message.channelId,
+						text: chunk,
+						thread_ts: message.threadId ?? (message.direct ? undefined : message.messageId),
+						mrkdwn: false,
+						parse: "none",
+						link_names: false,
+						unfurl_links: false,
+						unfurl_media: false,
+					},
+					sendSignal,
+					deps.fetch,
+				);
+			}
+		},
+	};
+}

package/src/messenger/telegram.ts

@@ -0,0 +1,241 @@
+import { resolveMessengerToken } from "./config";
+import { MessengerHttpError, messengerFetchJson, splitMessengerText, waitForMessengerRetry } from "./http";
+import {
+	isRecord,
+	type MessengerAdapter,
+	type MessengerMessage,
+	type MessengerPlatformConfig,
+	type MessengerTransportDeps,
+} from "./types";
+
+interface TelegramIdentity {
+	id: number;
+	username: string;
+}
+
+class TelegramApiError extends Error {
+	constructor(
+		readonly status: number,
+		readonly retryAfterMs = 0,
+	) {
+		super("Telegram API request failed");
+	}
+}
+
+function isInteger(value: unknown): value is number {
+	return typeof value === "number" && Number.isSafeInteger(value);
+}
+
+function isPositiveId(value: unknown): value is number {
+	return isInteger(value) && value > 0;
+}
+
+function parseIdentity(value: unknown): TelegramIdentity {
+	if (
+		!isRecord(value) ||
+		!isPositiveId(value.id) ||
+		value.is_bot !== true ||
+		typeof value.username !== "string" ||
+		!/^[a-zA-Z0-9_]{1,32}$/.test(value.username)
+	) {
+		throw new TelegramApiError(400);
+	}
+	return { id: value.id, username: value.username };
+}
+
+function stripMention(
+	text: string,
+	entities: unknown,
+	identity: TelegramIdentity,
+): { text: string; mentioned: boolean } {
+	const mention = `@${identity.username.toLowerCase()}`;
+	const ranges: { start: number; end: number }[] = [];
+	if (Array.isArray(entities)) {
+		for (const entity of entities) {
+			if (
+				!isRecord(entity) ||
+				!isInteger(entity.offset) ||
+				!isPositiveId(entity.length) ||
+				entity.offset < 0 ||
+				entity.offset + entity.length > text.length
+			) {
+				continue;
+			}
+			const start = entity.offset;
+			const end = start + entity.length;
+			const value = text.slice(start, end).toLowerCase();
+			if (
+				(entity.type === "mention" && value === mention) ||
+				(entity.type === "text_mention" && isRecord(entity.user) && entity.user.id === identity.id)
+			) {
+				ranges.push({ start, end });
+			} else if (
+				entity.type === "bot_command" &&
+				/^\/[a-z0-9_]+@[a-z0-9_]+$/.test(value) &&
+				value.endsWith(mention)
+			) {
+				ranges.push({ start: end - mention.length, end });
+			}
+		}
+	} else if (entities === undefined) {
+		const pattern = new RegExp(`(^|[^\\p{L}\\p{N}_@])@${identity.username}(?![\\p{L}\\p{N}_])`, "giu");
+		for (const match of text.matchAll(pattern)) {
+			const start = (match.index ?? 0) + match[1]!.length;
+			ranges.push({ start, end: start + mention.length });
+		}
+	}
+	if (ranges.length === 0) return { text, mentioned: false };
+	ranges.sort((left, right) => left.start - right.start);
+	let cursor = 0;
+	let stripped = "";
+	for (const range of ranges) {
+		if (range.start < cursor) continue;
+		stripped += text.slice(cursor, range.start);
+		cursor = range.end;
+	}
+	return { text: (stripped + text.slice(cursor)).trim(), mentioned: true };
+}
+
+function parseMessage(value: unknown, identity: TelegramIdentity): MessengerMessage | undefined {
+	if (
+		!isRecord(value) ||
+		!isPositiveId(value.message_id) ||
+		typeof value.text !== "string" ||
+		!isRecord(value.from) ||
+		!isPositiveId(value.from.id) ||
+		value.from.is_bot !== false ||
+		!isRecord(value.chat) ||
+		!isInteger(value.chat.id) ||
+		value.chat.id === 0 ||
+		(value.chat.type !== "private" && value.chat.type !== "group" && value.chat.type !== "supergroup") ||
+		(value.message_thread_id !== undefined && !isPositiveId(value.message_thread_id)) ||
+		value.edit_date !== undefined ||
+		value.sender_chat !== undefined
+	) {
+		return undefined;
+	}
+	const content = stripMention(value.text, value.entities, identity);
+	const direct = value.chat.type === "private";
+	if (!content.text.trim()) return undefined;
+	return {
+		platform: "telegram",
+		accountId: String(identity.id),
+		channelId: String(value.chat.id),
+		senderId: String(value.from.id),
+		messageId: String(value.message_id),
+		text: content.text,
+		...(value.message_thread_id === undefined ? {} : { threadId: String(value.message_thread_id) }),
+		direct,
+		mentioned: content.mentioned,
+	};
+}
+
+function isPermanent(error: unknown): boolean {
+	if (!(error instanceof TelegramApiError || error instanceof MessengerHttpError)) return false;
+	return error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429;
+}
+
+export function createTelegramAdapter(
+	config: MessengerPlatformConfig,
+	env: Record<string, string | undefined> = process.env,
+	deps: MessengerTransportDeps = {},
+): MessengerAdapter {
+	const token = resolveMessengerToken(config.tokenEnv, env);
+	if (!token?.trim()) throw new Error("Telegram bot token is missing");
+	const baseUrl = `https://api.telegram.org/bot${encodeURIComponent(token).replaceAll("%3A", ":")}/`;
+	let running = false;
+	let offset = 0;
+
+	async function request(method: string, parameters: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
+		const response = await messengerFetchJson(
+			`${baseUrl}${method}`,
+			{ method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(parameters) },
+			signal,
+			deps.fetch,
+		);
+		if (!isRecord(response) || typeof response.ok !== "boolean") throw new TelegramApiError(400);
+		if (!response.ok) {
+			const status = isInteger(response.error_code) ? response.error_code : 400;
+			const retryAfter = isRecord(response.parameters) ? response.parameters.retry_after : undefined;
+			throw new TelegramApiError(status, isPositiveId(retryAfter) ? Math.min(retryAfter, 300) * 1_000 : 0);
+		}
+		if (!("result" in response)) throw new TelegramApiError(400);
+		return response.result;
+	}
+
+	return {
+		platform: "telegram",
+		async start(onMessage, signal) {
+			if (signal.aborted) return;
+			if (running) throw new Error("Telegram adapter is already running");
+			running = true;
+			const stopped = Promise.withResolvers<void>();
+			const onAbort = () => stopped.resolve();
+			signal.addEventListener("abort", onAbort, { once: true });
+			let identity: TelegramIdentity | undefined;
+			let retryMs = 1_000;
+			try {
+				while (!signal.aborted) {
+					try {
+						identity ??= parseIdentity(await request("getMe", {}, signal));
+						if (signal.aborted) break;
+						const updates = await request(
+							"getUpdates",
+							{ offset, timeout: 25, allowed_updates: ["message"] },
+							signal,
+						);
+						if (!Array.isArray(updates)) throw new TelegramApiError(400);
+						retryMs = 1_000;
+						for (const update of updates) {
+							if (signal.aborted) break;
+							if (
+								!isRecord(update) ||
+								!isInteger(update.update_id) ||
+								update.update_id < 0 ||
+								update.update_id === Number.MAX_SAFE_INTEGER
+							) {
+								throw new TelegramApiError(400);
+							}
+							if (update.update_id < offset) continue;
+							offset = update.update_id + 1;
+							const message = parseMessage(update.message, identity);
+							if (!message) continue;
+							const processing = Promise.resolve()
+								.then(() => onMessage(message))
+								.catch(() => {});
+							await Promise.race([processing, stopped.promise]);
+						}
+					} catch (error) {
+						if (signal.aborted) break;
+						if (isPermanent(error)) throw new Error("Telegram authentication or polling configuration failed");
+						const delay =
+							error instanceof TelegramApiError || error instanceof MessengerHttpError
+								? Math.max(retryMs, error.retryAfterMs ?? 0)
+								: retryMs;
+						await waitForMessengerRetry(delay, signal);
+						retryMs = Math.min(retryMs * 2, 30_000);
+					}
+				}
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+				running = false;
+			}
+		},
+		async send(message, text, signal) {
+			const threadId = message.threadId === undefined ? undefined : Number(message.threadId);
+			if (threadId !== undefined && !isPositiveId(threadId)) throw new Error("Telegram topic identifier is invalid");
+			for (const chunk of splitMessengerText(text, 4_096)) {
+				const result = await request(
+					"sendMessage",
+					{
+						chat_id: message.channelId,
+						text: chunk,
+						...(threadId === undefined ? {} : { message_thread_id: threadId }),
+					},
+					signal,
+				);
+				if (!isRecord(result) || !isPositiveId(result.message_id)) throw new TelegramApiError(400);
+			}
+		},
+	};
+}