@tool-bridge/server 0.21.1 → 0.22.1

package/dist/telegram-MYYO3JND.js

@@ -0,0 +1,1767 @@
+import {
+  createProviderHttpClient
+} from "./chunk-BNMLA2RC.js";
+import {
+  asJsonObject,
+  booleanValue,
+  compactDefined,
+  finiteNumber,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  requireApiKey,
+  upstreamError
+} from "./chunk-X7ZUTKHR.js";
+import {
+  assertPublicHttpUrl
+} from "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/telegram/api.ts
+var SERVICE = "telegram";
+var API_BASE = "https://api.telegram.org";
+var REQUEST_TIMEOUT_MS = 3e4;
+var http = createProviderHttpClient({ baseUrl: API_BASE, service: SERVICE });
+function asRecord(value) {
+  const result = asJsonObject(value);
+  if (result === void 0) {
+    throw new TBError("unavailable", "Telegram \u8FD4\u56DE\u4E86\u975E\u9884\u671F\u7684\u5BF9\u8C61\u8D1F\u8F7D", { retryable: true });
+  }
+  return result;
+}
+function assertBotToken(botToken) {
+  if (botToken.length === 0 || /[/?#\s]/u.test(botToken)) {
+    throw new TBError("invalid_argument", "telegram bot token is malformed");
+  }
+}
+function methodUrl(botToken, method) {
+  assertBotToken(botToken);
+  return `${API_BASE}/bot${botToken}/${method}`;
+}
+function readEnvelope(response) {
+  if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+    return response.bodyKind === "json" ? asJsonObject(response.data) ?? {} : {};
+  }
+  const body = typeof response.data === "string" ? response.data : "";
+  return {
+    ok: false,
+    description: body === "" ? `telegram request failed with ${response.status}` : body,
+    error_code: response.status
+  };
+}
+function telegramError(statusCode, responseOk, payload, method) {
+  const code = finiteNumber(payload.error_code) ?? (responseOk ? void 0 : statusCode);
+  const status = code ?? 502;
+  const description = trimmedText(payload.description) ?? `telegram ${method} request failed with ${status}`;
+  if (status === 429) {
+    const retryAfter = finiteNumber(asJsonObject(payload.parameters)?.retry_after);
+    return upstreamError(429, retryAfter === void 0 ? description : `${description} Retry after ${retryAfter} seconds.`);
+  }
+  return upstreamError(status, description);
+}
+async function request(ctx, method, body) {
+  const botToken = requireApiKey(ctx, SERVICE);
+  const result = await http.request({
+    path: methodUrl(botToken, method),
+    method: body === void 0 ? "GET" : "POST",
+    ...body === void 0 ? {} : { json: body },
+    responseType: "auto",
+    invalidJson: "text",
+    timeoutMs: REQUEST_TIMEOUT_MS,
+    sensitiveValues: [botToken],
+    mapError: (context) => {
+      const payload2 = readEnvelope(context);
+      return telegramError(context.status, false, payload2, method);
+    },
+    mapTransportError: ({ kind, message }) => kind === "timeout" ? upstreamError(504, `telegram ${method} \u8BF7\u6C42\u8D85\u65F6(${REQUEST_TIMEOUT_MS / 1e3} \u79D2)`) : upstreamError(502, `telegram ${method} \u8BF7\u6C42\u5931\u8D25: ${message ?? "\u672A\u77E5\u9519\u8BEF"}`)
+  });
+  const payload = readEnvelope(result);
+  if (payload.ok !== true) throw telegramError(result.status, true, payload, method);
+  if (payload.result === void 0) {
+    throw new TBError("unavailable", `telegram ${method} response did not include result`, { retryable: true });
+  }
+  return payload.result;
+}
+async function booleanAction(ctx, method, body) {
+  await request(ctx, method, body);
+  return { success: true };
+}
+function jsonLike(value) {
+  if (typeof value === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      throw new TBError("invalid_argument", "invalid JSON string input");
+    }
+    const result = asJsonObject(parsed);
+    if (result === void 0) throw new TBError("invalid_argument", "JSON string input must decode to an object");
+    return result;
+  }
+  return asJsonObject(value);
+}
+function publicUrl(value) {
+  const candidate = trimmedText(value);
+  if (candidate === void 0) return void 0;
+  return assertPublicHttpUrl(candidate).toString();
+}
+function urlOrFileId(value) {
+  const candidate = trimmedText(value);
+  if (candidate === void 0 || !/^https?:\/\//iu.test(candidate)) return value;
+  return publicUrl(candidate);
+}
+function normalizeUser(value) {
+  return {
+    id: Number(value.id),
+    isBot: Boolean(value.is_bot),
+    firstName: String(value.first_name ?? ""),
+    username: trimmedText(value.username),
+    languageCode: trimmedText(value.language_code),
+    canJoinGroups: booleanValue(value.can_join_groups),
+    canReadAllGroupMessages: booleanValue(value.can_read_all_group_messages),
+    supportsInlineQueries: booleanValue(value.supports_inline_queries),
+    canConnectToBusiness: booleanValue(value.can_connect_to_business),
+    hasMainWebApp: booleanValue(value.has_main_web_app)
+  };
+}
+function normalizeChat(value) {
+  return {
+    id: Number(value.id),
+    type: String(value.type ?? ""),
+    title: trimmedText(value.title),
+    username: trimmedText(value.username),
+    firstName: trimmedText(value.first_name),
+    lastName: trimmedText(value.last_name),
+    isForum: booleanValue(value.is_forum)
+  };
+}
+function normalizePhotoSize(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    width: Number(value.width),
+    height: Number(value.height),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeDocument(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    fileName: trimmedText(value.file_name),
+    mimeType: trimmedText(value.mime_type),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeVideoQuality(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    width: Number(value.width),
+    height: Number(value.height),
+    codec: String(value.codec ?? ""),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeVideo(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    width: Number(value.width),
+    height: Number(value.height),
+    duration: Number(value.duration),
+    thumbnail: value.thumbnail ? normalizePhotoSize(asRecord(value.thumbnail)) : void 0,
+    cover: Array.isArray(value.cover) ? value.cover.map((item) => normalizePhotoSize(asRecord(item))) : void 0,
+    startTimestamp: finiteNumber(value.start_timestamp),
+    qualities: Array.isArray(value.qualities) ? value.qualities.map((item) => normalizeVideoQuality(asRecord(item))) : void 0,
+    fileName: trimmedText(value.file_name),
+    mimeType: trimmedText(value.mime_type),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeAudio(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    duration: Number(value.duration),
+    performer: trimmedText(value.performer),
+    title: trimmedText(value.title),
+    fileName: trimmedText(value.file_name),
+    mimeType: trimmedText(value.mime_type),
+    fileSize: finiteNumber(value.file_size),
+    thumbnail: value.thumbnail ? normalizePhotoSize(asRecord(value.thumbnail)) : void 0
+  };
+}
+function normalizeVoice(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    duration: Number(value.duration),
+    mimeType: trimmedText(value.mime_type),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeAnimation(value) {
+  return {
+    fileId: String(value.file_id ?? ""),
+    fileUniqueId: String(value.file_unique_id ?? ""),
+    width: Number(value.width),
+    height: Number(value.height),
+    duration: Number(value.duration),
+    thumbnail: value.thumbnail ? normalizePhotoSize(asRecord(value.thumbnail)) : void 0,
+    fileName: trimmedText(value.file_name),
+    mimeType: trimmedText(value.mime_type),
+    fileSize: finiteNumber(value.file_size)
+  };
+}
+function normalizeContact(value) {
+  return {
+    phoneNumber: String(value.phone_number ?? ""),
+    firstName: String(value.first_name ?? ""),
+    lastName: trimmedText(value.last_name),
+    userId: finiteNumber(value.user_id),
+    vcard: trimmedText(value.vcard)
+  };
+}
+function normalizeLocation(value) {
+  return {
+    latitude: Number(value.latitude),
+    longitude: Number(value.longitude),
+    horizontalAccuracy: finiteNumber(value.horizontal_accuracy),
+    livePeriod: finiteNumber(value.live_period),
+    heading: finiteNumber(value.heading),
+    proximityAlertRadius: finiteNumber(value.proximity_alert_radius)
+  };
+}
+function normalizeVenue(value) {
+  return {
+    location: normalizeLocation(asRecord(value.location)),
+    title: String(value.title ?? ""),
+    address: String(value.address ?? ""),
+    foursquareId: trimmedText(value.foursquare_id),
+    foursquareType: trimmedText(value.foursquare_type),
+    googlePlaceId: trimmedText(value.google_place_id),
+    googlePlaceType: trimmedText(value.google_place_type)
+  };
+}
+function normalizeDice(value) {
+  return {
+    emoji: String(value.emoji ?? ""),
+    value: Number(value.value)
+  };
+}
+function normalizePoll(value) {
+  return {
+    id: String(value.id ?? ""),
+    question: String(value.question ?? ""),
+    options: Array.isArray(value.options) ? value.options.map((option) => ({
+      text: String(asRecord(option).text ?? ""),
+      voterCount: Number(asRecord(option).voter_count ?? 0)
+    })) : [],
+    totalVoterCount: Number(value.total_voter_count ?? 0),
+    isClosed: Boolean(value.is_closed),
+    isAnonymous: Boolean(value.is_anonymous),
+    type: value.type === "quiz" ? "quiz" : "regular",
+    allowsMultipleAnswers: Boolean(value.allows_multiple_answers),
+    closeDate: finiteNumber(value.close_date),
+    openPeriod: finiteNumber(value.open_period),
+    explanation: trimmedText(value.explanation),
+    correctOptionId: finiteNumber(value.correct_option_id)
+  };
+}
+function normalizeMessage(value) {
+  return {
+    messageId: Number(value.message_id),
+    date: Number(value.date),
+    chat: normalizeChat(asRecord(value.chat)),
+    from: value.from ? normalizeUser(asRecord(value.from)) : void 0,
+    senderChat: value.sender_chat ? normalizeChat(asRecord(value.sender_chat)) : void 0,
+    text: trimmedText(value.text),
+    caption: trimmedText(value.caption),
+    photo: Array.isArray(value.photo) ? value.photo.map((item) => normalizePhotoSize(asRecord(item))) : void 0,
+    document: value.document ? normalizeDocument(asRecord(value.document)) : void 0,
+    location: value.location ? normalizeLocation(asRecord(value.location)) : void 0,
+    poll: value.poll ? normalizePoll(asRecord(value.poll)) : void 0,
+    entities: Array.isArray(value.entities) ? value.entities.map((item) => asRecord(item)) : void 0,
+    captionEntities: Array.isArray(value.caption_entities) ? value.caption_entities.map((item) => asRecord(item)) : void 0,
+    forwardDate: finiteNumber(value.forward_date),
+    forwardFrom: value.forward_from ? normalizeUser(asRecord(value.forward_from)) : void 0,
+    forwardFromChat: value.forward_from_chat ? normalizeChat(asRecord(value.forward_from_chat)) : void 0,
+    forwardFromMessageId: finiteNumber(value.forward_from_message_id),
+    forwardSignature: trimmedText(value.forward_signature),
+    forwardSenderName: trimmedText(value.forward_sender_name),
+    linkPreviewOptions: value.link_preview_options ? asRecord(value.link_preview_options) : void 0,
+    businessConnectionId: trimmedText(value.business_connection_id),
+    video: value.video ? normalizeVideo(asRecord(value.video)) : void 0,
+    audio: value.audio ? normalizeAudio(asRecord(value.audio)) : void 0,
+    voice: value.voice ? normalizeVoice(asRecord(value.voice)) : void 0,
+    animation: value.animation ? normalizeAnimation(asRecord(value.animation)) : void 0,
+    contact: value.contact ? normalizeContact(asRecord(value.contact)) : void 0,
+    venue: value.venue ? normalizeVenue(asRecord(value.venue)) : void 0,
+    dice: value.dice ? normalizeDice(asRecord(value.dice)) : void 0
+  };
+}
+function normalizeBusinessBotRights(value) {
+  return {
+    canReply: booleanValue(value.can_reply),
+    canReadMessages: booleanValue(value.can_read_messages),
+    canDeleteSentMessages: booleanValue(value.can_delete_sent_messages),
+    canDeleteAllMessages: booleanValue(value.can_delete_all_messages),
+    canEditName: booleanValue(value.can_edit_name),
+    canEditBio: booleanValue(value.can_edit_bio),
+    canEditProfilePhoto: booleanValue(value.can_edit_profile_photo),
+    canEditUsername: booleanValue(value.can_edit_username),
+    canChangeGiftSettings: booleanValue(value.can_change_gift_settings),
+    canViewGiftsAndStars: booleanValue(value.can_view_gifts_and_stars),
+    canConvertGiftsToStars: booleanValue(value.can_convert_gifts_to_stars),
+    canTransferAndUpgradeGifts: booleanValue(value.can_transfer_and_upgrade_gifts),
+    canTransferStars: booleanValue(value.can_transfer_stars),
+    canManageStories: booleanValue(value.can_manage_stories)
+  };
+}
+function normalizeBusinessConnection(value) {
+  return {
+    id: String(value.id ?? ""),
+    user: normalizeUser(asRecord(value.user)),
+    userChatId: Number(value.user_chat_id),
+    date: Number(value.date),
+    rights: value.rights ? normalizeBusinessBotRights(asRecord(value.rights)) : void 0,
+    isEnabled: Boolean(value.is_enabled)
+  };
+}
+function normalizeBusinessMessagesDeleted(value) {
+  return {
+    businessConnectionId: String(value.business_connection_id ?? ""),
+    chat: normalizeChat(asRecord(value.chat)),
+    messageIds: Array.isArray(value.message_ids) ? value.message_ids.map((id) => Number(id)) : []
+  };
+}
+function normalizeUpdate(value) {
+  return {
+    updateId: Number(value.update_id),
+    message: value.message ? normalizeMessage(asRecord(value.message)) : void 0,
+    editedMessage: value.edited_message ? normalizeMessage(asRecord(value.edited_message)) : void 0,
+    channelPost: value.channel_post ? normalizeMessage(asRecord(value.channel_post)) : void 0,
+    editedChannelPost: value.edited_channel_post ? normalizeMessage(asRecord(value.edited_channel_post)) : void 0,
+    callbackQuery: value.callback_query ? asRecord(value.callback_query) : void 0,
+    businessConnection: value.business_connection ? normalizeBusinessConnection(asRecord(value.business_connection)) : void 0,
+    businessMessage: value.business_message ? normalizeMessage(asRecord(value.business_message)) : void 0,
+    editedBusinessMessage: value.edited_business_message ? normalizeMessage(asRecord(value.edited_business_message)) : void 0,
+    deletedBusinessMessages: value.deleted_business_messages ? normalizeBusinessMessagesDeleted(asRecord(value.deleted_business_messages)) : void 0
+  };
+}
+function normalizeWebhookInfo(value) {
+  return {
+    url: String(value.url ?? ""),
+    hasCustomCertificate: Boolean(value.has_custom_certificate),
+    pendingUpdateCount: Number(value.pending_update_count ?? 0),
+    ipAddress: trimmedText(value.ip_address),
+    lastErrorDate: finiteNumber(value.last_error_date),
+    lastErrorMessage: trimmedText(value.last_error_message),
+    lastSynchronizationErrorDate: finiteNumber(value.last_synchronization_error_date),
+    maxConnections: finiteNumber(value.max_connections),
+    allowedUpdates: Array.isArray(value.allowed_updates) ? value.allowed_updates.map((item) => String(item)) : void 0
+  };
+}
+function normalizeChatMember(value) {
+  return {
+    status: String(value.status ?? ""),
+    user: normalizeUser(asRecord(value.user)),
+    customTitle: trimmedText(value.custom_title),
+    isAnonymous: booleanValue(value.is_anonymous),
+    untilDate: finiteNumber(value.until_date),
+    canBeEdited: booleanValue(value.can_be_edited),
+    canChangeInfo: booleanValue(value.can_change_info),
+    canManageChat: booleanValue(value.can_manage_chat),
+    canInviteUsers: booleanValue(value.can_invite_users),
+    canPinMessages: booleanValue(value.can_pin_messages),
+    canEditMessages: booleanValue(value.can_edit_messages),
+    canPostMessages: booleanValue(value.can_post_messages),
+    canDeleteMessages: booleanValue(value.can_delete_messages),
+    canPromoteMembers: booleanValue(value.can_promote_members),
+    canRestrictMembers: booleanValue(value.can_restrict_members),
+    canManageVideoChats: booleanValue(value.can_manage_video_chats),
+    canManageTopics: booleanValue(value.can_manage_topics)
+  };
+}
+function normalizeChatPermissions(value) {
+  const permissions = asRecord(value);
+  return compactDefined({
+    can_send_messages: permissions.canSendMessages,
+    can_send_audios: permissions.canSendAudios,
+    can_send_documents: permissions.canSendDocuments,
+    can_send_photos: permissions.canSendPhotos,
+    can_send_videos: permissions.canSendVideos,
+    can_send_video_notes: permissions.canSendVideoNotes,
+    can_send_voice_notes: permissions.canSendVoiceNotes,
+    can_send_polls: permissions.canSendPolls,
+    can_send_other_messages: permissions.canSendOtherMessages,
+    can_add_web_page_previews: permissions.canAddWebPagePreviews,
+    can_change_info: permissions.canChangeInfo,
+    can_invite_users: permissions.canInviteUsers,
+    can_pin_messages: permissions.canPinMessages,
+    can_manage_topics: permissions.canManageTopics
+  });
+}
+function normalizeChatInviteLink(value) {
+  return {
+    inviteLink: String(value.invite_link ?? ""),
+    creator: normalizeUser(asRecord(value.creator)),
+    createsJoinRequest: Boolean(value.creates_join_request),
+    isPrimary: Boolean(value.is_primary),
+    isRevoked: Boolean(value.is_revoked),
+    name: trimmedText(value.name),
+    expireDate: finiteNumber(value.expire_date),
+    memberLimit: finiteNumber(value.member_limit),
+    pendingJoinRequestCount: finiteNumber(value.pending_join_request_count),
+    subscriptionPeriod: finiteNumber(value.subscription_period),
+    subscriptionPrice: finiteNumber(value.subscription_price)
+  };
+}
+function assertIncreasingMessageIds(value) {
+  const increasing = value.every((id, index) => index === 0 || value[index - 1] < id);
+  if (!increasing) throw new TBError("invalid_argument", "messageIds must be in strictly increasing order");
+}
+function assertEditMessageTarget(input) {
+  const hasInlineTarget = input.inlineMessageId != null;
+  const hasChatTarget = input.chatId != null || input.messageId != null;
+  if (hasInlineTarget && hasChatTarget) {
+    throw new TBError("invalid_argument", "edit_message_text accepts either inlineMessageId or chatId/messageId");
+  }
+  if (!hasInlineTarget && !(input.chatId != null && input.messageId != null)) {
+    throw new TBError("invalid_argument", "edit_message_text requires inlineMessageId or chatId with messageId");
+  }
+}
+async function getMe(_input, ctx) {
+  return normalizeUser(asRecord(await request(ctx, "getMe")));
+}
+async function getWebhookInfo(_input, ctx) {
+  return normalizeWebhookInfo(asRecord(await request(ctx, "getWebhookInfo")));
+}
+function asArray(value) {
+  if (!Array.isArray(value)) {
+    throw new TBError("unavailable", "Telegram \u8FD4\u56DE\u4E86\u975E\u9884\u671F\u7684\u6570\u7EC4\u8D1F\u8F7D", { retryable: true });
+  }
+  return value;
+}
+async function getUpdates(input, ctx) {
+  const result = await request(ctx, "getUpdates", compactDefined({
+    offset: input.offset,
+    limit: input.limit,
+    timeout: input.timeout,
+    allowed_updates: input.allowedUpdates
+  }));
+  return { updates: asArray(result).map((update) => normalizeUpdate(asRecord(update))) };
+}
+async function sendMessage(input, ctx) {
+  const result = await request(ctx, "sendMessage", compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    text: input.text,
+    parse_mode: input.parseMode,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent,
+    message_thread_id: input.messageThreadId,
+    // Bot API 已经把 reply_to_message_id / disable_web_page_preview 换成了嵌套对象,
+    // 入参保留扁平写法是为了好用,转换只能在这里做。
+    reply_parameters: input.replyToMessageId != null ? { message_id: input.replyToMessageId } : void 0,
+    link_preview_options: input.disableWebPagePreview === true ? { is_disabled: true } : void 0
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function copyMessage(input, ctx) {
+  const result = asRecord(await request(ctx, "copyMessage", compactDefined({
+    chat_id: input.chatId,
+    from_chat_id: input.fromChatId,
+    message_id: input.messageId,
+    message_thread_id: input.messageThreadId,
+    caption: input.caption,
+    parse_mode: input.parseMode,
+    show_caption_above_media: input.showCaptionAboveMedia,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent
+  })));
+  return { messageId: Number(result.message_id) };
+}
+async function transferMessages(ctx, method, input) {
+  assertIncreasingMessageIds(input.messageIds);
+  const result = await request(ctx, method, compactDefined({
+    chat_id: input.chatId,
+    from_chat_id: input.fromChatId,
+    message_ids: input.messageIds,
+    message_thread_id: input.messageThreadId,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent,
+    remove_caption: method === "copyMessages" ? input.removeCaption : void 0
+  }));
+  return { messageIds: asArray(result).map((message) => Number(asRecord(message).message_id)) };
+}
+function copyMessages(input, ctx) {
+  return transferMessages(ctx, "copyMessages", input);
+}
+function forwardMessages(input, ctx) {
+  return transferMessages(ctx, "forwardMessages", input);
+}
+function deleteMessages(input, ctx) {
+  return booleanAction(ctx, "deleteMessages", {
+    chat_id: input.chatId,
+    message_ids: input.messageIds
+  });
+}
+function setMessageReaction(input, ctx) {
+  return booleanAction(ctx, "setMessageReaction", compactDefined({
+    chat_id: input.chatId,
+    message_id: input.messageId,
+    reaction: input.reaction,
+    is_big: input.isBig
+  }));
+}
+function sendChatAction(input, ctx) {
+  return booleanAction(ctx, "sendChatAction", compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_thread_id: input.messageThreadId,
+    action: input.action
+  }));
+}
+async function sendMedia(ctx, method, field, input) {
+  const source = input;
+  const result = await request(ctx, method, compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_thread_id: input.messageThreadId,
+    [field]: urlOrFileId(source[field]),
+    caption: source.caption,
+    parse_mode: source.parseMode,
+    duration: source.duration,
+    width: source.width,
+    height: source.height,
+    performer: source.performer,
+    title: source.title,
+    cover: urlOrFileId(source.cover),
+    start_timestamp: source.startTimestamp,
+    show_caption_above_media: source.showCaptionAboveMedia,
+    has_spoiler: source.hasSpoiler,
+    supports_streaming: source.supportsStreaming,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent
+  }));
+  return normalizeMessage(asRecord(result));
+}
+function sendVideo(input, ctx) {
+  return sendMedia(ctx, "sendVideo", "video", input);
+}
+function sendAudio(input, ctx) {
+  return sendMedia(ctx, "sendAudio", "audio", input);
+}
+function sendVoice(input, ctx) {
+  return sendMedia(ctx, "sendVoice", "voice", input);
+}
+function sendAnimation(input, ctx) {
+  return sendMedia(ctx, "sendAnimation", "animation", input);
+}
+async function sendMediaGroup(input, ctx) {
+  const result = await request(ctx, "sendMediaGroup", compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_thread_id: input.messageThreadId,
+    media: input.media,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent
+  }));
+  return { messages: asArray(result).map((message) => normalizeMessage(asRecord(message))) };
+}
+async function sendStructuredMessage(ctx, method, fields, input) {
+  const result = await request(ctx, method, compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_thread_id: input.messageThreadId,
+    ...fields,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent
+  }));
+  return normalizeMessage(asRecord(result));
+}
+function sendContact(input, ctx) {
+  return sendStructuredMessage(ctx, "sendContact", {
+    phone_number: input.phoneNumber,
+    first_name: input.firstName,
+    last_name: input.lastName,
+    vcard: input.vcard
+  }, input);
+}
+function sendVenue(input, ctx) {
+  return sendStructuredMessage(ctx, "sendVenue", {
+    latitude: input.latitude,
+    longitude: input.longitude,
+    title: input.title,
+    address: input.address,
+    foursquare_id: input.foursquareId,
+    foursquare_type: input.foursquareType,
+    google_place_id: input.googlePlaceId,
+    google_place_type: input.googlePlaceType
+  }, input);
+}
+function sendDice(input, ctx) {
+  return sendStructuredMessage(ctx, "sendDice", { emoji: input.emoji }, input);
+}
+async function getBusinessConnection(input, ctx) {
+  const result = await request(ctx, "getBusinessConnection", {
+    business_connection_id: input.businessConnectionId
+  });
+  return normalizeBusinessConnection(asRecord(result));
+}
+function readBusinessMessage(input, ctx) {
+  return booleanAction(ctx, "readBusinessMessage", {
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_id: input.messageId
+  });
+}
+function deleteBusinessMessages(input, ctx) {
+  return booleanAction(ctx, "deleteBusinessMessages", {
+    business_connection_id: input.businessConnectionId,
+    message_ids: input.messageIds
+  });
+}
+async function editMessageText(input, ctx) {
+  assertEditMessageTarget(input);
+  const result = await request(ctx, "editMessageText", compactDefined({
+    chat_id: input.chatId,
+    message_id: input.messageId,
+    inline_message_id: input.inlineMessageId,
+    text: input.text,
+    parse_mode: input.parseMode,
+    link_preview_options: input.disableWebPagePreview === true ? { is_disabled: true } : void 0
+  }));
+  if (result === true) {
+    return { edited: true, message: null, inlineMessageId: trimmedText(input.inlineMessageId) ?? null };
+  }
+  return { edited: true, message: normalizeMessage(asRecord(result)), inlineMessageId: null };
+}
+async function sendPhoto(input, ctx) {
+  const result = await request(ctx, "sendPhoto", compactDefined({
+    chat_id: input.chatId,
+    photo: urlOrFileId(input.photo),
+    caption: input.caption,
+    parse_mode: input.parseMode,
+    disable_notification: input.disableNotification,
+    protect_content: input.protectContent,
+    message_thread_id: input.messageThreadId,
+    reply_parameters: input.replyToMessageId != null ? { message_id: input.replyToMessageId } : void 0
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function sendDocument(input, ctx) {
+  const result = await request(ctx, "sendDocument", compactDefined({
+    chat_id: input.chatId,
+    document: urlOrFileId(input.document),
+    caption: input.caption,
+    parse_mode: input.parseMode,
+    thumbnail: urlOrFileId(input.thumbnail),
+    reply_markup: jsonLike(input.replyMarkup),
+    reply_to_message_id: input.replyToMessageId,
+    disable_notification: input.disableNotification,
+    disable_content_type_detection: input.disableContentTypeDetection
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function sendPoll(input, ctx) {
+  if (input.openPeriod != null && input.closeDate != null) {
+    throw new TBError("invalid_argument", "send_poll accepts only one of openPeriod or closeDate");
+  }
+  if (input.type === "quiz" && input.correctOptionId == null) {
+    throw new TBError("invalid_argument", "send_poll quiz polls require correctOptionId");
+  }
+  const result = await request(ctx, "sendPoll", compactDefined({
+    chat_id: input.chatId,
+    question: input.question,
+    options: input.options,
+    type: input.type,
+    is_anonymous: input.isAnonymous,
+    allows_multiple_answers: input.allowsMultipleAnswers,
+    correct_option_id: input.correctOptionId,
+    explanation: input.explanation,
+    explanation_parse_mode: input.explanationParseMode,
+    open_period: input.openPeriod,
+    close_date: input.closeDate,
+    is_closed: input.isClosed,
+    disable_notification: input.disableNotification,
+    reply_to_message_id: input.replyToMessageId,
+    reply_markup: jsonLike(input.replyMarkup)
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function getChat(input, ctx) {
+  return normalizeChat(asRecord(await request(ctx, "getChat", { chat_id: input.chatId })));
+}
+async function getChatMember(input, ctx) {
+  const result = await request(ctx, "getChatMember", { chat_id: input.chatId, user_id: input.userId });
+  return normalizeChatMember(asRecord(result));
+}
+async function getChatAdministrators(input, ctx) {
+  const result = await request(ctx, "getChatAdministrators", { chat_id: input.chatId });
+  return { administrators: asArray(result).map((member) => normalizeChatMember(asRecord(member))) };
+}
+async function getChatMembersCount(input, ctx) {
+  const result = await request(ctx, "getChatMemberCount", { chat_id: input.chatId });
+  const count = finiteNumber(result);
+  if (count === void 0) {
+    throw new TBError("unavailable", "Telegram \u7684\u6210\u5458\u6570\u4E0D\u662F\u4E00\u4E2A\u6570\u5B57", { retryable: true });
+  }
+  return { memberCount: count };
+}
+function banChatMember(input, ctx) {
+  return booleanAction(ctx, "banChatMember", compactDefined({
+    chat_id: input.chatId,
+    user_id: input.userId,
+    until_date: input.untilDate,
+    revoke_messages: input.revokeMessages
+  }));
+}
+function unbanChatMember(input, ctx) {
+  return booleanAction(ctx, "unbanChatMember", compactDefined({
+    chat_id: input.chatId,
+    user_id: input.userId,
+    only_if_banned: input.onlyIfBanned
+  }));
+}
+function restrictChatMember(input, ctx) {
+  return booleanAction(ctx, "restrictChatMember", compactDefined({
+    chat_id: input.chatId,
+    user_id: input.userId,
+    permissions: normalizeChatPermissions(input.permissions),
+    use_independent_chat_permissions: input.useIndependentChatPermissions,
+    until_date: input.untilDate
+  }));
+}
+function promoteChatMember(input, ctx) {
+  return booleanAction(ctx, "promoteChatMember", compactDefined({
+    chat_id: input.chatId,
+    user_id: input.userId,
+    is_anonymous: input.isAnonymous,
+    can_manage_chat: input.canManageChat,
+    can_delete_messages: input.canDeleteMessages,
+    can_manage_video_chats: input.canManageVideoChats,
+    can_restrict_members: input.canRestrictMembers,
+    can_promote_members: input.canPromoteMembers,
+    can_change_info: input.canChangeInfo,
+    can_invite_users: input.canInviteUsers,
+    can_post_stories: input.canPostStories,
+    can_edit_stories: input.canEditStories,
+    can_delete_stories: input.canDeleteStories,
+    can_post_messages: input.canPostMessages,
+    can_edit_messages: input.canEditMessages,
+    can_pin_messages: input.canPinMessages,
+    can_manage_topics: input.canManageTopics,
+    can_manage_direct_messages: input.canManageDirectMessages,
+    can_manage_tags: input.canManageTags
+  }));
+}
+function setChatPermissions(input, ctx) {
+  return booleanAction(ctx, "setChatPermissions", compactDefined({
+    chat_id: input.chatId,
+    permissions: normalizeChatPermissions(input.permissions),
+    use_independent_chat_permissions: input.useIndependentChatPermissions
+  }));
+}
+function pinChatMessage(input, ctx) {
+  return booleanAction(ctx, "pinChatMessage", compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_id: input.messageId,
+    disable_notification: input.disableNotification
+  }));
+}
+function unpinChatMessage(input, ctx) {
+  return booleanAction(ctx, "unpinChatMessage", compactDefined({
+    business_connection_id: input.businessConnectionId,
+    chat_id: input.chatId,
+    message_id: input.messageId
+  }));
+}
+function unpinAllChatMessages(input, ctx) {
+  return booleanAction(ctx, "unpinAllChatMessages", { chat_id: input.chatId });
+}
+function approveChatJoinRequest(input, ctx) {
+  return booleanAction(ctx, "approveChatJoinRequest", { chat_id: input.chatId, user_id: input.userId });
+}
+function declineChatJoinRequest(input, ctx) {
+  return booleanAction(ctx, "declineChatJoinRequest", { chat_id: input.chatId, user_id: input.userId });
+}
+function deleteMessage(input, ctx) {
+  return booleanAction(ctx, "deleteMessage", { chat_id: input.chatId, message_id: input.messageId });
+}
+async function forwardMessage(input, ctx) {
+  const result = await request(ctx, "forwardMessage", compactDefined({
+    chat_id: input.chatId,
+    from_chat_id: input.fromChatId,
+    message_id: input.messageId,
+    disable_notification: input.disableNotification
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function sendLocation(input, ctx) {
+  const result = await request(ctx, "sendLocation", compactDefined({
+    chat_id: input.chatId,
+    latitude: input.latitude,
+    longitude: input.longitude,
+    horizontal_accuracy: input.horizontalAccuracy,
+    live_period: input.livePeriod,
+    heading: input.heading,
+    proximity_alert_radius: input.proximityAlertRadius,
+    disable_notification: input.disableNotification,
+    reply_to_message_id: input.replyToMessageId,
+    reply_markup: jsonLike(input.replyMarkup)
+  }));
+  return normalizeMessage(asRecord(result));
+}
+async function exportChatInviteLink(input, ctx) {
+  const result = await request(ctx, "exportChatInviteLink", { chat_id: input.chatId });
+  if (typeof result !== "string") {
+    throw new TBError("unavailable", "Telegram \u7684\u9080\u8BF7\u94FE\u63A5\u4E0D\u662F\u4E00\u4E2A\u5B57\u7B26\u4E32", { retryable: true });
+  }
+  return { inviteLink: result };
+}
+async function mutateChatInviteLink(ctx, method, input) {
+  const source = input;
+  if (source.memberLimit != null && source.createsJoinRequest === true) {
+    throw new TBError("invalid_argument", "memberLimit cannot be combined with createsJoinRequest");
+  }
+  const result = await request(ctx, method, compactDefined({
+    chat_id: input.chatId,
+    invite_link: source.inviteLink,
+    name: source.name,
+    expire_date: source.expireDate,
+    member_limit: source.memberLimit,
+    creates_join_request: source.createsJoinRequest
+  }));
+  return normalizeChatInviteLink(asRecord(result));
+}
+function createChatInviteLink(input, ctx) {
+  return mutateChatInviteLink(ctx, "createChatInviteLink", input);
+}
+function editChatInviteLink(input, ctx) {
+  return mutateChatInviteLink(ctx, "editChatInviteLink", input);
+}
+function revokeChatInviteLink(input, ctx) {
+  return mutateChatInviteLink(ctx, "revokeChatInviteLink", input);
+}
+function answerCallbackQuery(input, ctx) {
+  return booleanAction(ctx, "answerCallbackQuery", compactDefined({
+    callback_query_id: input.callbackQueryId,
+    text: input.text,
+    show_alert: input.showAlert,
+    url: publicUrl(input.url),
+    cache_time: input.cacheTime
+  }));
+}
+function setMyCommands(input, ctx) {
+  return booleanAction(ctx, "setMyCommands", compactDefined({
+    commands: input.commands,
+    scope: jsonLike(input.scope),
+    language_code: input.languageCode
+  }));
+}
+function setWebhook(input, ctx) {
+  return booleanAction(ctx, "setWebhook", compactDefined({
+    // Telegram 会主动回访这个地址,故它同样要过出站可达性判定(填内网地址等于让上游探我们的内网)。
+    url: publicUrl(input.url),
+    secret_token: input.secretToken,
+    max_connections: input.maxConnections,
+    allowed_updates: input.allowedUpdates,
+    drop_pending_updates: input.dropPendingUpdates
+  }));
+}
+function deleteWebhook(input, ctx) {
+  return booleanAction(ctx, "deleteWebhook", compactDefined({ drop_pending_updates: input.dropPendingUpdates }));
+}
+
+// ../plugins/src/telegram/schema.ts
+import { z } from "zod/v4";
+var getMeInput = z.strictObject({}).describe("Action input.");
+var getMeOutput = z.looseObject({}).describe("A Telegram user or bot record.");
+var getWebhookInfoInput = z.strictObject({}).describe("Action input.");
+var getWebhookInfoOutput = z.looseObject({}).describe("Telegram webhook status information.");
+var getUpdatesInput = z.strictObject({
+  offset: z.int().describe("The update ID offset to start polling from.").optional(),
+  limit: z.int().min(1).max(100).describe("The maximum number of updates to return.").optional(),
+  timeout: z.int().min(0).max(50).describe("The long-polling timeout in seconds.").optional(),
+  allowedUpdates: z.array(z.string().min(1)).describe("The update types to receive.").optional()
+}).describe("Action input.");
+var getUpdatesOutput = z.strictObject({
+  updates: z.array(z.looseObject({}).describe("A Telegram update payload.")).describe("The updates returned by Telegram.")
+}).describe("Action output.");
+var sendMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  text: z.string().min(1).max(4096).describe("The text of the message to send."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the message silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the sent message from forwarding and saving.").optional(),
+  disableWebPagePreview: z.boolean().describe("Whether to disable link previews in the message.").optional(),
+  messageThreadId: z.int().min(1).describe("The forum topic ID for the target message thread.").optional(),
+  replyToMessageId: z.int().min(1).describe("The message ID to reply to.").optional()
+}).describe("Action input.");
+var sendMessageOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var copyMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  fromChatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("A Telegram message identifier."),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  caption: z.string().max(1024).describe("A replacement media caption.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  showCaptionAboveMedia: z.boolean().describe("Whether to show the replacement caption above the media.").optional(),
+  disableNotification: z.boolean().describe("Whether to copy the message silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the copied message from forwarding and saving.").optional()
+}).describe("Action input.");
+var copyMessageOutput = z.strictObject({
+  messageId: z.int().min(1).describe("A Telegram message identifier.")
+}).describe("Action output.");
+var copyMessagesInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  fromChatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).min(1).max(100).describe("The identifiers of 1-100 Telegram messages."),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to deliver the messages silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the messages from forwarding and saving.").optional(),
+  removeCaption: z.boolean().describe("Whether to remove captions from copied messages.").optional()
+}).describe("Action input.");
+var copyMessagesOutput = z.strictObject({
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).describe("The returned message identifiers.")
+}).describe("Action output.");
+var forwardMessagesInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  fromChatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).min(1).max(100).describe("The identifiers of 1-100 Telegram messages."),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to deliver the messages silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the messages from forwarding and saving.").optional()
+}).describe("Action input.");
+var forwardMessagesOutput = z.strictObject({
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).describe("The returned message identifiers.")
+}).describe("Action output.");
+var deleteMessagesInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).min(1).max(100).describe("The identifiers of 1-100 Telegram messages.")
+}).describe("Action input.");
+var deleteMessagesOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var setMessageReactionInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("A Telegram message identifier."),
+  reaction: z.array(z.looseObject({}).describe("A Telegram ReactionType object.")).max(1).describe("The reaction types to set; an empty array removes the reaction.").optional(),
+  isBig: z.boolean().describe("Whether to display a large reaction animation.").optional()
+}).describe("Action input.");
+var setMessageReactionOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var sendChatActionInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  action: 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"]).describe("The activity status to broadcast."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional()
+}).describe("Action input.");
+var sendChatActionOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var sendVideoInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  video: z.string().min(1).describe("The HTTP URL or Telegram file_id of the MPEG-4 video to send."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  caption: z.string().max(1024).describe("The media caption.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  duration: z.int().min(0).describe("The media duration in seconds.").optional(),
+  width: z.int().min(1).describe("The video width.").optional(),
+  height: z.int().min(1).describe("The video height.").optional(),
+  cover: z.string().min(1).describe("The HTTP URL or Telegram file_id of the video cover.").optional(),
+  startTimestamp: z.int().min(0).describe("The start timestamp shown for the video.").optional(),
+  showCaptionAboveMedia: z.boolean().describe("Whether to show the caption above the video.").optional(),
+  hasSpoiler: z.boolean().describe("Whether to cover the video with a spoiler animation.").optional(),
+  supportsStreaming: z.boolean().describe("Whether the video supports streaming.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the media silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the media from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendVideoOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendAudioInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  audio: z.string().min(1).describe("The HTTP URL or Telegram file_id of the MP3 or M4A audio to send."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  caption: z.string().max(1024).describe("The media caption.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  duration: z.int().min(0).describe("The media duration in seconds.").optional(),
+  performer: z.string().describe("The audio performer.").optional(),
+  title: z.string().describe("The audio track name.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the media silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the media from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendAudioOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendVoiceInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  voice: z.string().min(1).describe("The HTTP URL or Telegram file_id of the OGG, MP3, or M4A voice message."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  caption: z.string().max(1024).describe("The media caption.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  duration: z.int().min(0).describe("The media duration in seconds.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the media silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the media from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendVoiceOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendAnimationInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  animation: z.string().min(1).describe("The HTTP URL or Telegram file_id of the GIF or silent MPEG-4 animation."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  caption: z.string().max(1024).describe("The media caption.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  duration: z.int().min(0).describe("The media duration in seconds.").optional(),
+  width: z.int().min(1).describe("The animation width.").optional(),
+  height: z.int().min(1).describe("The animation height.").optional(),
+  showCaptionAboveMedia: z.boolean().describe("Whether to show the caption above the animation.").optional(),
+  hasSpoiler: z.boolean().describe("Whether to cover the animation with a spoiler animation.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the media silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the media from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendAnimationOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendMediaGroupInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  media: z.array(z.looseObject({
+    type: z.enum(["photo", "video", "audio", "document"]).describe("The media type."),
+    media: z.string().min(1).describe("The HTTP URL or Telegram file_id of the media.")
+  }).describe("A Telegram InputMedia object.")).min(2).max(10).describe("The InputMedia objects in the album."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the album silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the album from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendMediaGroupOutput = z.strictObject({
+  messages: z.array(z.looseObject({}).describe("A normalized Telegram message record.")).describe("The sent media messages.")
+}).describe("Action output.");
+var sendContactInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  phoneNumber: z.string().min(1).describe("The contact phone number."),
+  firstName: z.string().min(1).describe("The contact first name."),
+  lastName: z.string().describe("The contact last name.").optional(),
+  vcard: z.string().max(2048).describe("Additional contact data in vCard format.").optional(),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the contact silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the contact from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendContactOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendVenueInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  latitude: z.number().min(-90).max(90).describe("The venue latitude."),
+  longitude: z.number().min(-180).max(180).describe("The venue longitude."),
+  title: z.string().min(1).describe("The venue name."),
+  address: z.string().min(1).describe("The venue address."),
+  foursquareId: z.string().describe("The Foursquare place identifier.").optional(),
+  foursquareType: z.string().describe("The Foursquare place type.").optional(),
+  googlePlaceId: z.string().describe("The Google Places identifier.").optional(),
+  googlePlaceType: z.string().describe("The Google Places type.").optional(),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the venue silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the venue from forwarding and saving.").optional()
+}).describe("Action input.");
+var sendVenueOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendDiceInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  emoji: z.enum(["\u{1F3B2}", "\u{1F3AF}", "\u{1F3C0}", "\u26BD", "\u{1F3B3}", "\u{1F3B0}"]).describe("The dice animation emoji.").optional(),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  messageThreadId: z.int().min(1).describe("The target forum topic identifier.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the animation silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the animation from forwarding.").optional()
+}).describe("Action input.");
+var sendDiceOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var getBusinessConnectionInput = z.strictObject({
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.")
+}).describe("Action input.");
+var getBusinessConnectionOutput = z.looseObject({}).describe("A Telegram business connection record.");
+var readBusinessMessageInput = z.strictObject({
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection."),
+  chatId: z.int().describe("The identifier of the active private chat."),
+  messageId: z.int().min(1).describe("A Telegram message identifier.")
+}).describe("Action input.");
+var readBusinessMessageOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var deleteBusinessMessagesInput = z.strictObject({
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection."),
+  messageIds: z.array(z.int().min(1).describe("A Telegram message identifier.")).min(1).max(100).describe("The identifiers of 1-100 Telegram messages.")
+}).describe("Action input.");
+var deleteBusinessMessagesOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var editMessageTextInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.").optional(),
+  messageId: z.int().min(1).describe("The message ID to edit.").optional(),
+  inlineMessageId: z.string().min(1).describe("The inline message ID to edit.").optional(),
+  text: z.string().min(1).max(4096).describe("The new message text."),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  disableWebPagePreview: z.boolean().describe("Whether to disable link previews in the edited message.").optional()
+}).describe("Action input.");
+var editMessageTextOutput = z.strictObject({
+  edited: z.literal(true).describe("Whether the message edit succeeded."),
+  message: z.looseObject({}).describe("A normalized Telegram message record.").nullable(),
+  inlineMessageId: z.string().describe("The inline message ID when editing an inline message.").nullable()
+}).describe("Action output.");
+var sendPhotoInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  photo: z.string().min(1).describe("The photo URL or existing Telegram file_id to send."),
+  caption: z.string().max(1024).describe("The caption for the photo.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the photo silently.").optional(),
+  protectContent: z.boolean().describe("Whether to protect the photo from forwarding and saving.").optional(),
+  messageThreadId: z.int().min(1).describe("The forum topic ID for the target message thread.").optional(),
+  replyToMessageId: z.int().min(1).describe("The message ID to reply to.").optional()
+}).describe("Action input.");
+var sendPhotoOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendDocumentInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  document: z.string().min(1).describe("The document URL or existing Telegram file_id to send."),
+  caption: z.string().max(1024).describe("The caption for the document.").optional(),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  thumbnail: z.string().min(1).describe("An optional thumbnail URL or file identifier.").optional(),
+  replyMarkup: z.union([z.string().min(1).describe("A JSON-serialized object string."), z.looseObject({}).describe("A Telegram reply markup object.")]).describe("A Telegram reply markup object or JSON object string.").optional(),
+  replyToMessageId: z.int().min(1).describe("The message ID to reply to.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the document silently.").optional(),
+  disableContentTypeDetection: z.boolean().describe("Whether to disable server-side content type detection.").optional()
+}).describe("Action input.");
+var sendDocumentOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendPollInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  question: z.string().min(1).max(300).describe("The question shown at the top of the poll."),
+  options: z.array(z.string().min(1).max(100)).min(2).max(10).describe("The answer options available in the poll."),
+  type: z.enum(["regular", "quiz"]).describe("The type of poll to send.").optional(),
+  isAnonymous: z.boolean().describe("Whether the poll should be anonymous.").optional(),
+  allowsMultipleAnswers: z.boolean().describe("Whether users can choose multiple answers.").optional(),
+  correctOptionId: z.int().min(0).describe("The zero-based index of the correct option for quiz polls.").optional(),
+  explanation: z.string().max(200).describe("The explanation shown for quiz polls.").optional(),
+  explanationParseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).describe("The parse mode used for message entities.").optional(),
+  openPeriod: z.int().min(5).max(600).describe("The number of seconds the poll should stay open.").optional(),
+  closeDate: z.int().describe("The Unix timestamp when the poll should close.").optional(),
+  isClosed: z.boolean().describe("Whether the poll should be sent already closed.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the poll silently.").optional(),
+  replyToMessageId: z.int().min(1).describe("The message ID to reply to.").optional(),
+  replyMarkup: z.union([z.string().min(1).describe("A JSON-serialized object string."), z.looseObject({}).describe("A Telegram reply markup object.")]).describe("A Telegram reply markup object or JSON object string.").optional()
+}).describe("Action input.");
+var sendPollOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var getChatInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.")
+}).describe("Action input.");
+var getChatOutput = z.looseObject({}).describe("A Telegram chat record.");
+var getChatMemberInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The user ID of the chat member to fetch.")
+}).describe("Action input.");
+var getChatMemberOutput = z.looseObject({}).describe("A Telegram chat member record.");
+var getChatAdministratorsInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.")
+}).describe("Action input.");
+var getChatAdministratorsOutput = z.strictObject({
+  administrators: z.array(z.looseObject({}).describe("A Telegram chat member record.")).describe("The administrators visible to the bot in the chat.")
+}).describe("Action output.");
+var getChatMembersCountInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.")
+}).describe("Action input.");
+var getChatMembersCountOutput = z.strictObject({
+  memberCount: z.int().describe("The number of members currently in the chat.")
+}).describe("Action output.");
+var banChatMemberInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The target user identifier."),
+  untilDate: z.int().describe("The Unix timestamp when the ban ends.").optional(),
+  revokeMessages: z.boolean().describe("Whether to delete all messages from the banned user.").optional()
+}).describe("Action input.");
+var banChatMemberOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var unbanChatMemberInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The target user identifier."),
+  onlyIfBanned: z.boolean().describe("Whether to do nothing when the user is not currently banned.").optional()
+}).describe("Action input.");
+var unbanChatMemberOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var restrictChatMemberInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The target user identifier."),
+  permissions: z.strictObject({
+    canSendMessages: z.boolean().describe("Whether users may send text messages, contacts, giveaways, and locations.").optional(),
+    canSendAudios: z.boolean().describe("Whether users may send audio files.").optional(),
+    canSendDocuments: z.boolean().describe("Whether users may send documents.").optional(),
+    canSendPhotos: z.boolean().describe("Whether users may send photos.").optional(),
+    canSendVideos: z.boolean().describe("Whether users may send videos.").optional(),
+    canSendVideoNotes: z.boolean().describe("Whether users may send video notes.").optional(),
+    canSendVoiceNotes: z.boolean().describe("Whether users may send voice notes.").optional(),
+    canSendPolls: z.boolean().describe("Whether users may send polls.").optional(),
+    canSendOtherMessages: z.boolean().describe("Whether users may send animations, games, stickers, and other media.").optional(),
+    canAddWebPagePreviews: z.boolean().describe("Whether users may add web page previews.").optional(),
+    canChangeInfo: z.boolean().describe("Whether users may change chat information.").optional(),
+    canInviteUsers: z.boolean().describe("Whether users may invite new users.").optional(),
+    canPinMessages: z.boolean().describe("Whether users may pin messages.").optional(),
+    canManageTopics: z.boolean().describe("Whether users may create and manage forum topics.").optional()
+  }).describe("Action input."),
+  useIndependentChatPermissions: z.boolean().describe("Whether each media permission is applied independently.").optional(),
+  untilDate: z.int().describe("The Unix timestamp when the restrictions end.").optional()
+}).describe("Action input.");
+var restrictChatMemberOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var promoteChatMemberInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The target user identifier."),
+  isAnonymous: z.boolean().describe("Whether the administrator is hidden.").optional(),
+  canManageChat: z.boolean().describe("Whether the administrator can access general chat management features.").optional(),
+  canDeleteMessages: z.boolean().describe("Whether the administrator can delete other users' messages.").optional(),
+  canManageVideoChats: z.boolean().describe("Whether the administrator can manage video chats.").optional(),
+  canRestrictMembers: z.boolean().describe("Whether the administrator can restrict or ban members.").optional(),
+  canPromoteMembers: z.boolean().describe("Whether the administrator can appoint other administrators.").optional(),
+  canChangeInfo: z.boolean().describe("Whether the administrator can change chat information.").optional(),
+  canInviteUsers: z.boolean().describe("Whether the administrator can invite users.").optional(),
+  canPostStories: z.boolean().describe("Whether the administrator can post stories.").optional(),
+  canEditStories: z.boolean().describe("Whether the administrator can edit stories.").optional(),
+  canDeleteStories: z.boolean().describe("Whether the administrator can delete stories.").optional(),
+  canPostMessages: z.boolean().describe("Whether the administrator can post channel messages.").optional(),
+  canEditMessages: z.boolean().describe("Whether the administrator can edit channel messages.").optional(),
+  canPinMessages: z.boolean().describe("Whether the administrator can pin messages.").optional(),
+  canManageTopics: z.boolean().describe("Whether the administrator can manage forum topics.").optional(),
+  canManageDirectMessages: z.boolean().describe("Whether the administrator can manage channel direct messages.").optional(),
+  canManageTags: z.boolean().describe("Whether the administrator can manage member tags.").optional()
+}).describe("Action input.");
+var promoteChatMemberOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var setChatPermissionsInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  permissions: z.strictObject({
+    canSendMessages: z.boolean().describe("Whether users may send text messages, contacts, giveaways, and locations.").optional(),
+    canSendAudios: z.boolean().describe("Whether users may send audio files.").optional(),
+    canSendDocuments: z.boolean().describe("Whether users may send documents.").optional(),
+    canSendPhotos: z.boolean().describe("Whether users may send photos.").optional(),
+    canSendVideos: z.boolean().describe("Whether users may send videos.").optional(),
+    canSendVideoNotes: z.boolean().describe("Whether users may send video notes.").optional(),
+    canSendVoiceNotes: z.boolean().describe("Whether users may send voice notes.").optional(),
+    canSendPolls: z.boolean().describe("Whether users may send polls.").optional(),
+    canSendOtherMessages: z.boolean().describe("Whether users may send animations, games, stickers, and other media.").optional(),
+    canAddWebPagePreviews: z.boolean().describe("Whether users may add web page previews.").optional(),
+    canChangeInfo: z.boolean().describe("Whether users may change chat information.").optional(),
+    canInviteUsers: z.boolean().describe("Whether users may invite new users.").optional(),
+    canPinMessages: z.boolean().describe("Whether users may pin messages.").optional(),
+    canManageTopics: z.boolean().describe("Whether users may create and manage forum topics.").optional()
+  }).describe("Action input."),
+  useIndependentChatPermissions: z.boolean().describe("Whether each media permission is applied independently.").optional()
+}).describe("Action input.");
+var setChatPermissionsOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var pinChatMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("A Telegram message identifier."),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional(),
+  disableNotification: z.boolean().describe("Whether to suppress the pin notification.").optional()
+}).describe("Action input.");
+var pinChatMessageOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var unpinChatMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("A Telegram message identifier.").optional(),
+  businessConnectionId: z.string().min(1).describe("The unique identifier of the Telegram business connection.").optional()
+}).describe("Action input.");
+var unpinChatMessageOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var unpinAllChatMessagesInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.")
+}).describe("Action input.");
+var unpinAllChatMessagesOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var approveChatJoinRequestInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The user identifier from the join request.")
+}).describe("Action input.");
+var approveChatJoinRequestOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var declineChatJoinRequestInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  userId: z.int().describe("The user identifier from the join request.")
+}).describe("Action input.");
+var declineChatJoinRequestOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var deleteMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("The message ID to delete.")
+}).describe("Action input.");
+var deleteMessageOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var forwardMessageInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  fromChatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  messageId: z.int().min(1).describe("The source message ID to forward."),
+  disableNotification: z.boolean().describe("Whether to forward the message silently.").optional()
+}).describe("Action input.");
+var forwardMessageOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var sendLocationInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  latitude: z.number().min(-90).max(90).describe("The latitude of the location."),
+  longitude: z.number().min(-180).max(180).describe("The longitude of the location."),
+  horizontalAccuracy: z.number().min(0).max(1500).describe("The radius of uncertainty for the location, in meters.").optional(),
+  livePeriod: z.int().min(60).max(86400).describe("The live location update period in seconds.").optional(),
+  heading: z.int().min(1).max(360).describe("The direction in which the user is moving, in degrees.").optional(),
+  proximityAlertRadius: z.int().min(1).max(1e5).describe("The distance in meters for proximity alerts.").optional(),
+  disableNotification: z.boolean().describe("Whether to send the location silently.").optional(),
+  replyToMessageId: z.int().min(1).describe("The message ID to reply to.").optional(),
+  replyMarkup: z.union([z.string().min(1).describe("A JSON-serialized object string."), z.looseObject({}).describe("A Telegram reply markup object.")]).describe("A Telegram reply markup object or JSON object string.").optional()
+}).describe("Action input.");
+var sendLocationOutput = z.looseObject({}).describe("A normalized Telegram message record.");
+var exportChatInviteLinkInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username.")
+}).describe("Action input.");
+var exportChatInviteLinkOutput = z.strictObject({
+  inviteLink: z.string().describe("The exported invite link for the chat.")
+}).describe("Action output.");
+var createChatInviteLinkInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  name: z.string().max(32).describe("The invite link name.").optional(),
+  expireDate: z.int().describe("The Unix timestamp when the link expires.").optional(),
+  memberLimit: z.int().min(1).max(99999).describe("The maximum number of simultaneous members using the link.").optional(),
+  createsJoinRequest: z.boolean().describe("Whether users joining through the link require administrator approval.").optional()
+}).describe("Action input.");
+var createChatInviteLinkOutput = z.looseObject({}).describe("A Telegram chat invite link record.");
+var editChatInviteLinkInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  inviteLink: z.string().min(1).describe("The invite link to edit."),
+  name: z.string().max(32).describe("The invite link name.").optional(),
+  expireDate: z.int().describe("The Unix timestamp when the link expires.").optional(),
+  memberLimit: z.int().min(1).max(99999).describe("The maximum number of simultaneous members using the link.").optional(),
+  createsJoinRequest: z.boolean().describe("Whether users joining through the link require administrator approval.").optional()
+}).describe("Action input.");
+var editChatInviteLinkOutput = z.looseObject({}).describe("A Telegram chat invite link record.");
+var revokeChatInviteLinkInput = z.strictObject({
+  chatId: z.union([z.int().describe("A numeric Telegram chat identifier."), z.string().regex(new RegExp("^-?\\d+$")).describe("A numeric Telegram chat identifier encoded as a string."), z.string().regex(new RegExp("^@[A-Za-z0-9_]+$")).describe("A Telegram @username for a public chat or channel.")]).describe("The target Telegram chat ID or channel username."),
+  inviteLink: z.string().min(1).describe("The invite link to revoke.")
+}).describe("Action input.");
+var revokeChatInviteLinkOutput = z.looseObject({}).describe("A Telegram chat invite link record.");
+var answerCallbackQueryInput = z.strictObject({
+  callbackQueryId: z.string().min(1).describe("The callback query ID to answer."),
+  text: z.string().max(200).describe("The notification text to show to the user.").optional(),
+  showAlert: z.boolean().describe("Whether to show an alert instead of a notification.").optional(),
+  url: z.url().describe("The URL to open for the callback query.").optional(),
+  cacheTime: z.int().min(0).describe("The maximum time in seconds that the result may be cached client-side.").optional()
+}).describe("Action input.");
+var answerCallbackQueryOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var setMyCommandsInput = z.strictObject({
+  commands: z.array(z.strictObject({
+    command: z.string().regex(new RegExp("^[a-z0-9_]+$")).describe("The command text without the leading slash.").optional(),
+    description: z.string().min(1).max(256).describe("The description shown for the bot command.").optional()
+  })).min(1).max(100).describe("The bot commands to register."),
+  scope: z.union([z.string().min(1).describe("A JSON-serialized object string."), z.looseObject({}).describe("A Telegram reply markup object.")]).describe("A Telegram reply markup object or JSON object string.").optional(),
+  languageCode: z.string().min(2).max(35).describe("The language code for localized commands.").optional()
+}).describe("Action input.");
+var setMyCommandsOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var setWebhookInput = z.strictObject({
+  url: z.url().describe("The HTTPS webhook URL that Telegram should deliver updates to."),
+  secretToken: z.string().min(1).max(256).describe("The secret token Telegram should include in webhook requests.").optional(),
+  maxConnections: z.int().min(1).max(100).describe("The maximum number of concurrent webhook connections.").optional(),
+  allowedUpdates: z.array(z.string().min(1)).describe("The update types that should be delivered to the webhook.").optional(),
+  dropPendingUpdates: z.boolean().describe("Whether to drop all pending updates before setting the webhook.").optional()
+}).describe("Action input.");
+var setWebhookOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var deleteWebhookInput = z.strictObject({
+  dropPendingUpdates: z.boolean().describe("Whether to drop all pending updates when deleting the webhook.").optional()
+}).describe("Action input.");
+var deleteWebhookOutput = z.strictObject({
+  success: z.literal(true).describe("Whether the Telegram Bot API request succeeded.")
+}).describe("A success response payload.");
+var telegramActions = {
+  get_me: {
+    description: "Validate the bot token and return the bot profile from Telegram Bot API.",
+    effect: "read",
+    inputSchema: getMeInput,
+    outputSchema: z.toJSONSchema(getMeOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_webhook_info: {
+    description: "Return the webhook status configured for the bot.",
+    effect: "read",
+    inputSchema: getWebhookInfoInput,
+    outputSchema: z.toJSONSchema(getWebhookInfoOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_updates: {
+    description: "Poll pending updates for the bot. Use this only when webhook delivery is disabled or for debugging.",
+    effect: "read",
+    inputSchema: getUpdatesInput,
+    outputSchema: z.toJSONSchema(getUpdatesOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_message: {
+    description: "Send a text message to a chat, group, supergroup, channel, or forum topic.",
+    effect: "write",
+    inputSchema: sendMessageInput,
+    outputSchema: z.toJSONSchema(sendMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  copy_message: {
+    description: "Copy one message without linking back to the original message.",
+    effect: "write",
+    inputSchema: copyMessageInput,
+    outputSchema: z.toJSONSchema(copyMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  copy_messages: {
+    description: "Copy 1-100 messages without links to the originals while preserving album grouping.",
+    effect: "write",
+    inputSchema: copyMessagesInput,
+    outputSchema: z.toJSONSchema(copyMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  forward_messages: {
+    description: "Forward 1-100 messages while preserving links and album grouping.",
+    effect: "write",
+    inputSchema: forwardMessagesInput,
+    outputSchema: z.toJSONSchema(forwardMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_messages: {
+    description: "Delete 1-100 messages from one Telegram chat.",
+    effect: "destructive",
+    inputSchema: deleteMessagesInput,
+    outputSchema: z.toJSONSchema(deleteMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  set_message_reaction: {
+    description: "Replace the bot's chosen reaction on a Telegram message.",
+    effect: "write",
+    inputSchema: setMessageReactionInput,
+    outputSchema: z.toJSONSchema(setMessageReactionOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_chat_action: {
+    description: "Show a temporary typing, upload, recording, or location activity status in a chat.",
+    effect: "write",
+    inputSchema: sendChatActionInput,
+    outputSchema: z.toJSONSchema(sendChatActionOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_video: {
+    description: "Send an MPEG-4 video by URL or Telegram file_id.",
+    effect: "write",
+    inputSchema: sendVideoInput,
+    outputSchema: z.toJSONSchema(sendVideoOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_audio: {
+    description: "Send an MP3 or M4A audio track by URL or Telegram file_id.",
+    effect: "write",
+    inputSchema: sendAudioInput,
+    outputSchema: z.toJSONSchema(sendAudioOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_voice: {
+    description: "Send a playable voice message by URL or Telegram file_id.",
+    effect: "write",
+    inputSchema: sendVoiceInput,
+    outputSchema: z.toJSONSchema(sendVoiceOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_animation: {
+    description: "Send a GIF or silent MPEG-4 animation by URL or Telegram file_id.",
+    effect: "write",
+    inputSchema: sendAnimationInput,
+    outputSchema: z.toJSONSchema(sendAnimationOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_media_group: {
+    description: "Send an album containing 2-10 photos, videos, documents, or audio items.",
+    effect: "write",
+    inputSchema: sendMediaGroupInput,
+    outputSchema: z.toJSONSchema(sendMediaGroupOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_contact: {
+    description: "Send a phone contact to a Telegram chat.",
+    effect: "write",
+    inputSchema: sendContactInput,
+    outputSchema: z.toJSONSchema(sendContactOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_venue: {
+    description: "Send a venue with coordinates, title, address, and optional place identifiers.",
+    effect: "write",
+    inputSchema: sendVenueInput,
+    outputSchema: z.toJSONSchema(sendVenueOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_dice: {
+    description: "Send an animated dice, darts, basketball, football, bowling, or slot-machine emoji.",
+    effect: "write",
+    inputSchema: sendDiceInput,
+    outputSchema: z.toJSONSchema(sendDiceOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_business_connection: {
+    description: "Return the current state and granted rights of a Telegram business connection.",
+    effect: "read",
+    inputSchema: getBusinessConnectionInput,
+    outputSchema: z.toJSONSchema(getBusinessConnectionOutput, { io: "output", unrepresentable: "any" })
+  },
+  read_business_message: {
+    description: "Mark an incoming message as read on behalf of a connected Telegram business account.",
+    effect: "read",
+    inputSchema: readBusinessMessageInput,
+    outputSchema: z.toJSONSchema(readBusinessMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_business_messages: {
+    description: "Delete one or more messages on behalf of a connected Telegram business account.",
+    effect: "destructive",
+    inputSchema: deleteBusinessMessagesInput,
+    outputSchema: z.toJSONSchema(deleteBusinessMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  edit_message_text: {
+    description: "Edit the text of a previously sent message or an inline message.",
+    effect: "write",
+    inputSchema: editMessageTextInput,
+    outputSchema: z.toJSONSchema(editMessageTextOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_photo: {
+    description: "Send a photo by public URL or existing Telegram file_id.",
+    effect: "write",
+    inputSchema: sendPhotoInput,
+    outputSchema: z.toJSONSchema(sendPhotoOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_document: {
+    description: "Send a document by public URL or existing Telegram file_id.",
+    effect: "write",
+    inputSchema: sendDocumentInput,
+    outputSchema: z.toJSONSchema(sendDocumentOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_poll: {
+    description: "Send a native Telegram poll to a chat.",
+    effect: "write",
+    inputSchema: sendPollInput,
+    outputSchema: z.toJSONSchema(sendPollOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_chat: {
+    description: "Return metadata for a chat the bot can access.",
+    effect: "read",
+    inputSchema: getChatInput,
+    outputSchema: z.toJSONSchema(getChatOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_chat_member: {
+    description: "Return information about one chat member.",
+    effect: "read",
+    inputSchema: getChatMemberInput,
+    outputSchema: z.toJSONSchema(getChatMemberOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_chat_administrators: {
+    description: "Return the chat administrators visible to the bot.",
+    effect: "read",
+    inputSchema: getChatAdministratorsInput,
+    outputSchema: z.toJSONSchema(getChatAdministratorsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_chat_members_count: {
+    description: "Return the number of members in a chat.",
+    effect: "read",
+    inputSchema: getChatMembersCountInput,
+    outputSchema: z.toJSONSchema(getChatMembersCountOutput, { io: "output", unrepresentable: "any" })
+  },
+  ban_chat_member: {
+    description: "Ban a user from a group, supergroup, or channel.",
+    effect: "write",
+    inputSchema: banChatMemberInput,
+    outputSchema: z.toJSONSchema(banChatMemberOutput, { io: "output", unrepresentable: "any" })
+  },
+  unban_chat_member: {
+    description: "Unban a user so they can join the chat again.",
+    effect: "write",
+    inputSchema: unbanChatMemberInput,
+    outputSchema: z.toJSONSchema(unbanChatMemberOutput, { io: "output", unrepresentable: "any" })
+  },
+  restrict_chat_member: {
+    description: "Set temporary or permanent permissions for one supergroup member.",
+    effect: "write",
+    inputSchema: restrictChatMemberInput,
+    outputSchema: z.toJSONSchema(restrictChatMemberOutput, { io: "output", unrepresentable: "any" })
+  },
+  promote_chat_member: {
+    description: "Promote, update, or demote a supergroup or channel administrator.",
+    effect: "write",
+    inputSchema: promoteChatMemberInput,
+    outputSchema: z.toJSONSchema(promoteChatMemberOutput, { io: "output", unrepresentable: "any" })
+  },
+  set_chat_permissions: {
+    description: "Set default permissions for all members of a group or supergroup.",
+    effect: "write",
+    inputSchema: setChatPermissionsInput,
+    outputSchema: z.toJSONSchema(setChatPermissionsOutput, { io: "output", unrepresentable: "any" })
+  },
+  pin_chat_message: {
+    description: "Pin a message in a Telegram chat.",
+    effect: "write",
+    inputSchema: pinChatMessageInput,
+    outputSchema: z.toJSONSchema(pinChatMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  unpin_chat_message: {
+    description: "Unpin one message, or the most recently pinned message, from a Telegram chat.",
+    effect: "write",
+    inputSchema: unpinChatMessageInput,
+    outputSchema: z.toJSONSchema(unpinChatMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  unpin_all_chat_messages: {
+    description: "Remove all pinned messages from a Telegram chat.",
+    effect: "write",
+    inputSchema: unpinAllChatMessagesInput,
+    outputSchema: z.toJSONSchema(unpinAllChatMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  approve_chat_join_request: {
+    description: "Approve a user's pending request to join a Telegram chat.",
+    effect: "write",
+    inputSchema: approveChatJoinRequestInput,
+    outputSchema: z.toJSONSchema(approveChatJoinRequestOutput, { io: "output", unrepresentable: "any" })
+  },
+  decline_chat_join_request: {
+    description: "Decline a user's pending request to join a Telegram chat.",
+    effect: "write",
+    inputSchema: declineChatJoinRequestInput,
+    outputSchema: z.toJSONSchema(declineChatJoinRequestOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_message: {
+    description: "Delete a message from a chat.",
+    effect: "destructive",
+    inputSchema: deleteMessageInput,
+    outputSchema: z.toJSONSchema(deleteMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  forward_message: {
+    description: "Forward a message from one chat to another.",
+    effect: "write",
+    inputSchema: forwardMessageInput,
+    outputSchema: z.toJSONSchema(forwardMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_location: {
+    description: "Send a map location to a chat.",
+    effect: "write",
+    inputSchema: sendLocationInput,
+    outputSchema: z.toJSONSchema(sendLocationOutput, { io: "output", unrepresentable: "any" })
+  },
+  export_chat_invite_link: {
+    description: "Export the primary invite link for a Telegram chat.",
+    effect: "read",
+    inputSchema: exportChatInviteLinkInput,
+    outputSchema: z.toJSONSchema(exportChatInviteLinkOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_chat_invite_link: {
+    description: "Create an additional Telegram chat invite link with optional expiry or approval rules.",
+    effect: "write",
+    inputSchema: createChatInviteLinkInput,
+    outputSchema: z.toJSONSchema(createChatInviteLinkOutput, { io: "output", unrepresentable: "any" })
+  },
+  edit_chat_invite_link: {
+    description: "Edit an additional Telegram chat invite link created by the bot.",
+    effect: "write",
+    inputSchema: editChatInviteLinkInput,
+    outputSchema: z.toJSONSchema(editChatInviteLinkOutput, { io: "output", unrepresentable: "any" })
+  },
+  revoke_chat_invite_link: {
+    description: "Revoke a Telegram chat invite link created by the bot.",
+    effect: "destructive",
+    inputSchema: revokeChatInviteLinkInput,
+    outputSchema: z.toJSONSchema(revokeChatInviteLinkOutput, { io: "output", unrepresentable: "any" })
+  },
+  answer_callback_query: {
+    description: "Answer an inline keyboard callback query.",
+    effect: "write",
+    inputSchema: answerCallbackQueryInput,
+    outputSchema: z.toJSONSchema(answerCallbackQueryOutput, { io: "output", unrepresentable: "any" })
+  },
+  set_my_commands: {
+    description: "Set the bot command list exposed in Telegram clients.",
+    effect: "write",
+    inputSchema: setMyCommandsInput,
+    outputSchema: z.toJSONSchema(setMyCommandsOutput, { io: "output", unrepresentable: "any" })
+  },
+  set_webhook: {
+    description: "Configure a webhook endpoint for update delivery.",
+    effect: "write",
+    inputSchema: setWebhookInput,
+    outputSchema: z.toJSONSchema(setWebhookOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_webhook: {
+    description: "Delete the configured webhook and optionally drop pending updates.",
+    effect: "destructive",
+    inputSchema: deleteWebhookInput,
+    outputSchema: z.toJSONSchema(deleteWebhookOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/telegram/index.ts
+function createTelegramPlugin() {
+  return createProviderPlugin({
+    description: "Telegram Bot",
+    actions: telegramActions,
+    // 上游 credentialValidators 就是打 getMe 试 token,这里对应到同一个 action:
+    // effect 是 read、入参是空 strictObject,满足探针的三个条件。
+    credentialProbe: "get_me",
+    handlers: {
+      get_me: getMe,
+      get_webhook_info: getWebhookInfo,
+      get_updates: getUpdates,
+      send_message: sendMessage,
+      copy_message: copyMessage,
+      copy_messages: copyMessages,
+      forward_messages: forwardMessages,
+      delete_messages: deleteMessages,
+      set_message_reaction: setMessageReaction,
+      send_chat_action: sendChatAction,
+      send_video: sendVideo,
+      send_audio: sendAudio,
+      send_voice: sendVoice,
+      send_animation: sendAnimation,
+      send_media_group: sendMediaGroup,
+      send_contact: sendContact,
+      send_venue: sendVenue,
+      send_dice: sendDice,
+      get_business_connection: getBusinessConnection,
+      read_business_message: readBusinessMessage,
+      delete_business_messages: deleteBusinessMessages,
+      edit_message_text: editMessageText,
+      send_photo: sendPhoto,
+      send_document: sendDocument,
+      send_poll: sendPoll,
+      get_chat: getChat,
+      get_chat_member: getChatMember,
+      get_chat_administrators: getChatAdministrators,
+      get_chat_members_count: getChatMembersCount,
+      ban_chat_member: banChatMember,
+      unban_chat_member: unbanChatMember,
+      restrict_chat_member: restrictChatMember,
+      promote_chat_member: promoteChatMember,
+      set_chat_permissions: setChatPermissions,
+      pin_chat_message: pinChatMessage,
+      unpin_chat_message: unpinChatMessage,
+      unpin_all_chat_messages: unpinAllChatMessages,
+      approve_chat_join_request: approveChatJoinRequest,
+      decline_chat_join_request: declineChatJoinRequest,
+      delete_message: deleteMessage,
+      forward_message: forwardMessage,
+      send_location: sendLocation,
+      export_chat_invite_link: exportChatInviteLink,
+      create_chat_invite_link: createChatInviteLink,
+      edit_chat_invite_link: editChatInviteLink,
+      revoke_chat_invite_link: revokeChatInviteLink,
+      answer_callback_query: answerCallbackQuery,
+      set_my_commands: setMyCommands,
+      set_webhook: setWebhook,
+      delete_webhook: deleteWebhook
+    }
+  });
+}
+var telegram_default = createTelegramPlugin();
+export {
+  createTelegramPlugin,
+  telegram_default as default
+};