@divyacon/piece-telegram-bot 0.0.0-stage → 0.1.0

package/src/lib/action/send-location.action.ts

@@ -0,0 +1,76 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { sendLocationActionOutputSchema } from '../output-schemas';
+
+export const telegramSendLocationAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_location',
+  displayName: 'Send Location',
+  description: 'Send a geographic location (latitude/longitude) to a Telegram chat',
+  audience: 'human',
+  aiMetadata: { description: 'Sends a point location given as latitude and longitude to a Telegram chat, optionally as a live location that updates for a set period. Use to share a place or track a moving position; both coordinates are required. Not idempotent: each call posts a new location message.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    latitude: Property.Number({
+      displayName: 'Latitude',
+      description: 'Latitude of the location.',
+      required: true,
+    }),
+    longitude: Property.Number({
+      displayName: 'Longitude',
+      description: 'Longitude of the location.',
+      required: true,
+    }),
+    horizontal_accuracy: Property.Number({
+      displayName: 'Horizontal Accuracy',
+      description: 'Radius of uncertainty for the location, in meters (0–1500).',
+      required: false,
+    }),
+    live_period: Property.Number({
+      displayName: 'Live Period',
+      description:
+        'Number of seconds the location will be updated (60–86400). Use for live locations.',
+      required: false,
+    }),
+    heading: Property.Number({
+      displayName: 'Heading',
+      description: 'For live locations, direction the user is moving in degrees (1–360).',
+      required: false,
+    }),
+    proximity_alert_radius: Property.Number({
+      displayName: 'Proximity Alert Radius',
+      description:
+        'For live locations, the max distance (1–100000 m) for proximity alerts about approaching another chat member.',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendLocationActionOutputSchema,
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendLocation'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        latitude: ctx.propsValue.latitude,
+        longitude: ctx.propsValue.longitude,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+        horizontal_accuracy: ctx.propsValue.horizontal_accuracy ?? undefined,
+        live_period: ctx.propsValue.live_period ?? undefined,
+        heading: ctx.propsValue.heading ?? undefined,
+        proximity_alert_radius: ctx.propsValue.proximity_alert_radius ?? undefined,
+        disable_notification: ctx.propsValue.disable_notification ?? false,
+        protect_content: ctx.propsValue.protect_content ?? false,
+        reply_to_message_id: ctx.propsValue.reply_to_message_id ?? undefined,
+        reply_markup: ctx.propsValue.reply_markup ?? undefined,
+      },
+    });
+  },
+});

package/src/lib/action/send-media-group.action.ts

@@ -0,0 +1,98 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { sendMediaGroupActionOutputSchema } from '../output-schemas';
+
+const MEDIA_GROUP_LIMIT = 10;
+
+type MediaItem = {
+  type: 'photo' | 'video' | 'audio' | 'document';
+  media: string;
+  caption?: string;
+  parse_mode?: string;
+};
+
+export const telegramSendMediaGroupAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_media_group',
+  displayName: 'Send Media Group',
+  description:
+    'Send a group of 2–10 photos, videos, documents or audios as an album to a chat',
+  audience: 'human',
+  aiMetadata: { description: 'Sends 2–10 media items (each a public URL or a Telegram file_id) as a single grouped album to a chat. Use to post several photos/videos together; photo and video may be mixed, but audio-only and document-only groups cannot be combined with other types. Not idempotent: each call posts a new album.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    media: Property.Array({
+      displayName: 'Media',
+      description:
+        'Media items to send. Each must be a URL or a Telegram file_id. Mixing photo/video is allowed; audio and document groups cannot be mixed with other types.',
+      required: true,
+      properties: {
+        type: Property.StaticDropdown({
+          displayName: 'Type',
+          required: true,
+          options: {
+            options: [
+              { label: 'Photo', value: 'photo' },
+              { label: 'Video', value: 'video' },
+              { label: 'Audio', value: 'audio' },
+              { label: 'Document', value: 'document' },
+            ],
+          },
+          defaultValue: 'photo',
+        }),
+        media: Property.ShortText({
+          displayName: 'Media URL or File Id',
+          description:
+            'Public URL or a Telegram file_id of an already uploaded media item.',
+          required: true,
+        }),
+        caption: Property.LongText({
+          displayName: 'Caption',
+          required: false,
+        }),
+      },
+    }),
+    parse_mode: telegramCommons.parseModeProp(),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+  },
+  outputSchema: sendMediaGroupActionOutputSchema,
+  async run(ctx) {
+    const items = (ctx.propsValue.media ?? []) as Array<Record<string, unknown>>;
+    if (items.length < 2 || items.length > MEDIA_GROUP_LIMIT) {
+      throw new Error('A media group must contain 2–10 media items.');
+    }
+    const parseMode = telegramCommons.resolveParseMode(ctx.propsValue.parse_mode);
+
+    const media: MediaItem[] = items.map((item) => {
+      const type = String(item['type'] ?? 'photo') as MediaItem['type'];
+      const value = String(item['media'] ?? '');
+      if (!value) {
+        throw new Error('Each media item must define a URL or file_id.');
+      }
+      const caption = item['caption'] ? String(item['caption']) : undefined;
+      const mediaItem: MediaItem = { type, media: value };
+      if (caption) mediaItem.caption = caption;
+      if (caption && parseMode) mediaItem.parse_mode = parseMode;
+      return mediaItem;
+    });
+
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendMediaGroup'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+        media,
+        disable_notification: ctx.propsValue.disable_notification ?? false,
+        protect_content: ctx.propsValue.protect_content ?? false,
+        reply_to_message_id: ctx.propsValue.reply_to_message_id ?? undefined,
+      },
+    });
+  },
+});

package/src/lib/action/send-media.action.ts

@@ -0,0 +1,209 @@
+import {
+  ApFile,
+  createAction,
+  DynamicPropsValue,
+  Property,
+} from '@agnocon/pieces-framework';
+import {
+  HttpMessageBody,
+  HttpMethod,
+  QueryParams,
+  httpClient,
+} from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import FormData from 'form-data';
+import { sendMediaActionOutputSchema } from '../output-schemas';
+
+export const telegramSendMediaAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_media',
+  description: 'Send a media message (photo, video, sticker, GIF) through a Telegram bot',
+  audience: 'human',
+  aiMetadata: { description: 'Sends a single photo, video, sticker, or animated GIF to a Telegram chat, supplied either as an uploaded file or a previously uploaded Telegram file_id. Use when delivering one rich-media item with an optional caption; for multiple items in one album use Send Media Group. Not idempotent: each call posts a new message.', idempotent: false },
+  displayName: 'Send Media',
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    media_type: Property.StaticDropdown({
+      displayName: 'Media Type',
+      required: true,
+      options: {
+        disabled: false,
+        placeholder: 'Select media type',
+        options: [
+          { label: 'Image', value: 'photo' },
+          { label: 'Video', value: 'video' },
+          { label: 'Sticker', value: 'sticker' },
+          { label: 'GIF', value: 'animation' },
+        ],
+      },
+    }),
+    media: Property.DynamicProperties({
+      auth: telegramBotAuth,
+      displayName: 'Media Properties',
+      required: false,
+      refreshers: ['media_type'],
+      async props({ media_type }) {
+        const propsBuilders: Record<string, () => DynamicPropsValue> = {
+          photo: () => ({
+            photo: Property.File({
+              displayName: 'Image',
+              description: 'The image to be uploaded as a file',
+              required: false,
+            }),
+            photoId: Property.ShortText({
+              displayName: 'Image Id',
+              description:
+                "The image id previously uploaded to Telegram's servers",
+              required: false,
+            }),
+          }),
+          video: () => ({
+            video: Property.File({
+              displayName: 'Video',
+              description: 'The video to be uploaded as a file',
+              required: false,
+            }),
+            videoId: Property.ShortText({
+              displayName: 'Video Id',
+              description:
+                "The video id previously uploaded to Telegram's servers",
+              required: false,
+            }),
+          }),
+          sticker: () => ({
+            sticker: Property.File({
+              displayName: 'Sticker',
+              description:
+                'The sticker to be uploaded as a file (supports .WEBP files for static and .TGS for animated)',
+              required: false,
+            }),
+            emoji: Property.ShortText({
+              displayName: 'Emoji',
+              description:
+                'Emoji associated with the sticker. Only for just uploaded stickers',
+              required: false,
+            }),
+            stickerId: Property.ShortText({
+              displayName: 'Sticker Id',
+              description:
+                "The sticker id previously uploaded to Telegram's servers",
+              required: false,
+            }),
+          }),
+          animation: () => ({
+            animation: Property.File({
+              displayName: 'GIF',
+              description:
+                'The GIF or MPEG-4 without sound file to be uploaded as a auto-playing animation',
+              required: false,
+            }),
+            animationId: Property.ShortText({
+              displayName: 'GIF Id',
+              description:
+                "The GIF or MPEG-4 without sound id previously uploaded to Telegram's servers",
+              required: false,
+            }),
+            duration: Property.Number({
+              displayName: 'Duration',
+              description: 'Duration of sent video in seconds',
+              required: false,
+            }),
+          }),
+        };
+        const builder = propsBuilders[media_type as unknown as string];
+        if (!builder) {
+          return {};
+        }
+        return builder();
+      },
+    }),
+    format: telegramCommons.parseModeProp(),
+    instructions_format: telegramCommons.formatLinkInstructions(),
+    message: Property.LongText({
+      displayName: 'Caption',
+      description: 'The caption to send with the media',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendMediaActionOutputSchema,
+  async run(ctx) {
+    const mediaType = ctx.propsValue['media_type'];
+    if (!mediaType) {
+      throw new Error('media_type is required');
+    }
+
+    const methods: Partial<Record<string, string>> = {
+      photo: 'sendPhoto',
+      video: 'sendVideo',
+      sticker: 'sendSticker',
+      animation: 'sendAnimation',
+    };
+
+    const method = methods[mediaType];
+    if (!method) {
+      throw new Error('Unknown media type method (' + mediaType + ')');
+    }
+
+    const headers: Record<string, string> = {};
+    const queryParams: QueryParams = {};
+    let body: HttpMessageBody | undefined = undefined;
+
+    const file = ctx.propsValue.media?.[mediaType] as ApFile | undefined;
+    const id = ctx.propsValue.media?.[mediaType + 'Id'] as string | undefined;
+    const parseMode = telegramCommons.resolveParseMode(ctx.propsValue['format']);
+
+    if (file && file.data && file.filename) {
+      const form = new FormData();
+      form.append(mediaType, file.data, file.filename);
+      form.append('chat_id', ctx.propsValue['chat_id']);
+      if (ctx.propsValue['message']) {
+        form.append('caption', ctx.propsValue['message']);
+      }
+      if (ctx.propsValue['message_thread_id']) {
+        form.append('message_thread_id', ctx.propsValue['message_thread_id']);
+      }
+      if (parseMode) {
+        form.append('parse_mode', parseMode);
+      }
+      if (ctx.propsValue['disable_notification']) {
+        form.append('disable_notification', 'true');
+      }
+      if (ctx.propsValue['protect_content']) {
+        form.append('protect_content', 'true');
+      }
+      if (ctx.propsValue['reply_markup']) {
+        form.append('reply_markup', JSON.stringify(ctx.propsValue['reply_markup']));
+      }
+
+      body = form;
+      Object.assign(headers, form.getHeaders());
+    } else if (typeof id !== 'undefined' && id !== '') {
+      body = {
+        [mediaType]: id,
+        chat_id: ctx.propsValue['chat_id'],
+        caption: ctx.propsValue['message'] ?? undefined,
+        message_thread_id: ctx.propsValue['message_thread_id'] ?? undefined,
+        parse_mode: parseMode,
+        disable_notification: ctx.propsValue['disable_notification'] ?? false,
+        protect_content: ctx.propsValue['protect_content'] ?? false,
+        reply_markup: ctx.propsValue['reply_markup'] ?? undefined,
+      };
+    } else {
+      throw new Error('No media defined. Provide either a file or an id.');
+    }
+
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, method),
+      headers,
+      body,
+      queryParams,
+    });
+  },
+});

package/src/lib/action/send-poll.action.ts

@@ -0,0 +1,140 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { sendPollActionOutputSchema } from '../output-schemas';
+
+export const telegramSendPollAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_poll',
+  displayName: 'Send Poll',
+  description: 'Send a native Telegram poll (regular or quiz) to a chat',
+  audience: 'human',
+  aiMetadata: { description: 'Posts a native Telegram poll (regular or quiz) to a chat with 2–10 answer options. Use to collect votes or run a quiz; quiz polls require a correct_option_id and cannot allow multiple answers, and open_period and close_date are mutually exclusive. Not idempotent: each call creates a new poll.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    question: Property.ShortText({
+      displayName: 'Question',
+      description: 'Poll question, 1–300 characters.',
+      required: true,
+    }),
+    options: Property.Array({
+      displayName: 'Options',
+      description: 'List of answer options (2–10 options, each 1–100 characters).',
+      required: true,
+    }),
+    is_anonymous: Property.Checkbox({
+      displayName: 'Anonymous',
+      description: 'True, if the poll needs to be anonymous. Default true.',
+      required: false,
+      defaultValue: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'Poll Type',
+      description: 'Poll type. Defaults to "regular".',
+      required: false,
+      options: {
+        options: [
+          { label: 'Regular', value: 'regular' },
+          { label: 'Quiz', value: 'quiz' },
+        ],
+      },
+      defaultValue: 'regular',
+    }),
+    allows_multiple_answers: Property.Checkbox({
+      displayName: 'Allow Multiple Answers',
+      description: 'True if the poll allows multiple answers (regular polls only).',
+      required: false,
+      defaultValue: false,
+    }),
+    correct_option_id: Property.Number({
+      displayName: 'Correct Option Id (Quiz)',
+      description: '0-based index of the correct answer option (required for quizzes).',
+      required: false,
+    }),
+    explanation: Property.LongText({
+      displayName: 'Explanation (Quiz)',
+      description: 'Explanation shown when a user picks an incorrect answer (0–200 chars).',
+      required: false,
+    }),
+    explanation_parse_mode: telegramCommons.parseModeProp(),
+    open_period: Property.Number({
+      displayName: 'Open Period (seconds)',
+      description: 'Amount of time in seconds the poll will be active (5–600).',
+      required: false,
+    }),
+    close_date: Property.DateTime({
+      displayName: 'Close Date',
+      description: 'Point in time when the poll will be automatically closed.',
+      required: false,
+    }),
+    is_closed: Property.Checkbox({
+      displayName: 'Closed',
+      description: 'Pass True if the poll should be immediately closed. Useful for previews.',
+      required: false,
+      defaultValue: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendPollActionOutputSchema,
+  async run(ctx) {
+    const options = (ctx.propsValue.options ?? []).map((option) => String(option));
+    if (options.length < 2 || options.length > 10) {
+      throw new Error('A poll requires between 2 and 10 options.');
+    }
+    const pollType = ctx.propsValue.type ?? 'regular';
+    const correctOptionId = ctx.propsValue.correct_option_id;
+    if (pollType === 'quiz') {
+      if (correctOptionId === undefined || correctOptionId === null) {
+        throw new Error('Quiz polls require "Correct Option Id".');
+      }
+      if (correctOptionId < 0 || correctOptionId >= options.length) {
+        throw new Error(
+          `"Correct Option Id" must be between 0 and ${options.length - 1} (the index of an option).`
+        );
+      }
+      if (ctx.propsValue.allows_multiple_answers) {
+        throw new Error('Quiz polls cannot allow multiple answers.');
+      }
+    } else if (correctOptionId !== undefined && correctOptionId !== null) {
+      throw new Error('"Correct Option Id" is only valid for quiz polls. Set "Poll Type" to Quiz or clear this field.');
+    }
+    if (ctx.propsValue.open_period && ctx.propsValue.close_date) {
+      throw new Error('"Open Period" and "Close Date" are mutually exclusive — set at most one.');
+    }
+    const explanationParseMode = telegramCommons.resolveParseMode(
+      ctx.propsValue.explanation_parse_mode
+    );
+
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendPoll'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        question: ctx.propsValue.question,
+        options,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+        is_anonymous: ctx.propsValue.is_anonymous ?? true,
+        type: ctx.propsValue.type ?? 'regular',
+        allows_multiple_answers: ctx.propsValue.allows_multiple_answers ?? false,
+        correct_option_id: ctx.propsValue.correct_option_id ?? undefined,
+        explanation: ctx.propsValue.explanation ?? undefined,
+        explanation_parse_mode: explanationParseMode,
+        open_period: ctx.propsValue.open_period ?? undefined,
+        close_date: ctx.propsValue.close_date
+          ? Math.floor(new Date(ctx.propsValue.close_date).getTime() / 1000)
+          : undefined,
+        is_closed: ctx.propsValue.is_closed ?? false,
+        disable_notification: ctx.propsValue.disable_notification ?? false,
+        protect_content: ctx.propsValue.protect_content ?? false,
+        reply_to_message_id: ctx.propsValue.reply_to_message_id ?? undefined,
+        reply_markup: ctx.propsValue.reply_markup ?? undefined,
+      },
+    });
+  },
+});

package/src/lib/action/send-text-message.action.ts

@@ -0,0 +1,54 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { sendTextMessageActionOutputSchema } from '../output-schemas';
+
+export const telegramSendMessageAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_text_message',
+  description: 'Send a text message through a Telegram bot',
+  audience: 'human',
+  aiMetadata: { description: 'Posts a text message to a Telegram chat, group, or channel via the bot, addressed by chat_id (numeric id or @channelusername the bot can reach). Use to deliver notifications, replies, or alerts; supports Markdown/HTML formatting and inline keyboards. Not idempotent: each call sends a new message.', idempotent: false },
+  displayName: 'Send Text Message',
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    format: telegramCommons.parseModeProp(),
+    instructions_format: telegramCommons.formatLinkInstructions(),
+    web_page_preview: Property.Checkbox({
+      displayName: 'Disable Web Page Preview',
+      description: 'Disable link previews for links in this message.',
+      required: false,
+      defaultValue: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    message: Property.LongText({
+      displayName: 'Message',
+      description: 'The message to be sent',
+      required: true,
+    }),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendTextMessageActionOutputSchema,
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendMessage'),
+      body: {
+        chat_id: ctx.propsValue['chat_id'],
+        text: ctx.propsValue['message'],
+        message_thread_id: ctx.propsValue['message_thread_id'] ?? undefined,
+        parse_mode: telegramCommons.resolveParseMode(ctx.propsValue['format']),
+        reply_markup: ctx.propsValue['reply_markup'] ?? undefined,
+        disable_web_page_preview: ctx.propsValue['web_page_preview'] ?? false,
+        disable_notification: ctx.propsValue['disable_notification'] ?? false,
+        protect_content: ctx.propsValue['protect_content'] ?? false,
+        reply_to_message_id: ctx.propsValue['reply_to_message_id'] ?? undefined,
+      },
+    });
+  },
+});

package/src/lib/action/telegram-answer-callback-query.ts

@@ -0,0 +1,64 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramAnswerCallbackQueryActionOutputSchema } from '../output-schemas';
+
+export const telegramAnswerCallbackQuery = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_answer_callback_query',
+  displayName: 'Answer Callback Query',
+  description: 'Respond to a callback query raised by an inline keyboard button tap.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Acknowledges a callback query raised when a user taps an inline keyboard button, identified by callback_query_id (from the callback-query trigger payload), optionally showing a toast or alert. Use to stop the button spinner and give feedback; a given query can be answered only once. Not idempotent: it is a one-time response to that query.',
+    idempotent: false,
+  },
+  outputSchema: telegramAnswerCallbackQueryActionOutputSchema,
+  props: {
+    callback_query_id: Property.ShortText({
+      displayName: 'Callback Query Id',
+      description:
+        'Unique identifier of the callback query. Available on callback_query.id in the New Callback Query trigger payload.',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Text',
+      description:
+        'Text shown to the user. If not specified, nothing is shown (the spinner is just stopped).',
+      required: false,
+    }),
+    show_alert: Property.Checkbox({
+      displayName: 'Show Alert',
+      description:
+        'If True, an alert dialog is shown instead of a notification at the top of the screen.',
+      required: false,
+      defaultValue: false,
+    }),
+    url: Property.ShortText({
+      displayName: 'URL',
+      description: 'URL that will be opened by the user.',
+      required: false,
+    }),
+    cache_time: Property.Number({
+      displayName: 'Cache Time (seconds)',
+      description:
+        'The maximum amount of time in seconds the result of the callback query may be cached client-side.',
+      required: false,
+    }),
+  },
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'answerCallbackQuery'),
+      body: {
+        callback_query_id: ctx.propsValue.callback_query_id,
+        text: ctx.propsValue.text ?? undefined,
+        show_alert: ctx.propsValue.show_alert ?? false,
+        url: ctx.propsValue.url ?? undefined,
+        cache_time: ctx.propsValue.cache_time ?? undefined,
+      },
+    });
+  },
+});