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

package/src/lib/action/telegram-send-audio.ts

@@ -0,0 +1,157 @@
+import {
+  ApFile,
+  createAction,
+  Property,
+} from '@agnocon/pieces-framework';
+import {
+  HttpMessageBody,
+  HttpMethod,
+  httpClient,
+} from '@agnocon/pieces-common';
+import FormData from 'form-data';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendAudioActionOutputSchema } from '../output-schemas';
+
+export const telegramSendAudio = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_audio',
+  displayName: 'Send Audio',
+  description:
+    'Send an audio file to a Telegram chat (.MP3/.M4A — shown in the music player).',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Sends an audio file (.MP3/.M4A) that appears in the chat\'s music player (chat_id is a numeric id or @channelusername the bot can reach), supplied as an uploaded file OR a previously uploaded file_id, with optional performer and track title. Provide exactly one of audio or audio_id. Use for music or audio tracks; for a raw file attachment use telegram_send_document. Caption format defaults to plain text. Not idempotent: each call sends a new message.',
+    idempotent: false,
+  },
+  outputSchema: telegramSendAudioActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    audio: Property.File({
+      displayName: 'Audio',
+      description: 'The audio file to send (.MP3 or .M4A). Provide this or an audio_id.',
+      required: false,
+    }),
+    audio_id: Property.ShortText({
+      displayName: 'Audio Id',
+      description:
+        'Reuse an audio file previously uploaded to Telegram by passing its file_id. Provide this or an audio file.',
+      required: false,
+    }),
+    caption: Property.LongText({
+      displayName: 'Caption',
+      description: 'Optional caption (0–1024 chars).',
+      required: false,
+    }),
+    format: Property.StaticDropdown({
+      displayName: 'Caption Format',
+      description:
+        'How the caption should be parsed by Telegram. Defaults to plain text; only set MarkdownV2 or HTML when the caption is correctly escaped/tagged.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Plain Text', value: 'None' },
+          { label: 'Markdown (V2)', value: 'MarkdownV2' },
+          { label: 'HTML', value: 'HTML' },
+        ],
+      },
+      defaultValue: 'None',
+    }),
+    duration: Property.Number({
+      displayName: 'Duration',
+      description: 'Duration of the audio in seconds.',
+      required: false,
+    }),
+    performer: Property.ShortText({
+      displayName: 'Performer',
+      description: 'Performer / artist name.',
+      required: false,
+    }),
+    title: Property.ShortText({
+      displayName: 'Track Title',
+      description: 'Track title.',
+      required: false,
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: Property.Json({
+      displayName: 'Reply Markup',
+      description:
+        'Advanced/optional. A raw JSON-serialized inline keyboard, e.g. {"inline_keyboard":[[{"text":"Open","url":"https://example.com"}]]}. Malformed markup is rejected by Telegram.',
+      required: false,
+    }),
+  },
+  async run(ctx) {
+    const file = ctx.propsValue.audio as ApFile | undefined;
+    const audioId = ctx.propsValue.audio_id;
+    const parseMode = telegramCommons.resolveParseMode(ctx.propsValue.format);
+
+    if (!file && !audioId) {
+      throw new Error('Either an audio file or an audio id must be provided.');
+    }
+
+    const headers: Record<string, string> = {};
+    let body: HttpMessageBody;
+
+    if (file && file.data && file.filename) {
+      const form = new FormData();
+      form.append('audio', file.data, file.filename);
+      form.append('chat_id', ctx.propsValue.chat_id);
+      if (ctx.propsValue.caption) form.append('caption', ctx.propsValue.caption);
+      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.duration)
+        form.append('duration', String(ctx.propsValue.duration));
+      if (ctx.propsValue.performer)
+        form.append('performer', ctx.propsValue.performer);
+      if (ctx.propsValue.title) form.append('title', ctx.propsValue.title);
+      if (ctx.propsValue.disable_notification)
+        form.append('disable_notification', 'true');
+      if (ctx.propsValue.protect_content)
+        form.append('protect_content', 'true');
+      if (ctx.propsValue.reply_to_message_id) {
+        form.append(
+          'reply_to_message_id',
+          String(ctx.propsValue.reply_to_message_id)
+        );
+      }
+      if (ctx.propsValue.reply_markup) {
+        form.append('reply_markup', JSON.stringify(ctx.propsValue.reply_markup));
+      }
+      body = form;
+      Object.assign(headers, form.getHeaders());
+    } else {
+      body = {
+        chat_id: ctx.propsValue.chat_id,
+        audio: audioId,
+        caption: ctx.propsValue.caption ?? undefined,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+        parse_mode: parseMode,
+        duration: ctx.propsValue.duration ?? undefined,
+        performer: ctx.propsValue.performer ?? undefined,
+        title: ctx.propsValue.title ?? 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,
+      };
+    }
+
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendAudio'),
+      headers,
+      body,
+    });
+  },
+});

package/src/lib/action/telegram-send-chat-action.ts

@@ -0,0 +1,61 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendChatActionActionOutputSchema } from '../output-schemas';
+
+export const telegramSendChatAction = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_chat_action',
+  displayName: 'Send Chat Action',
+  description:
+    'Show a status (typing, uploading photo, recording voice, etc.) on behalf of the bot in a chat. The status is shown for up to 5 seconds.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Broadcasts a transient activity status (such as typing or uploading photo) in a chat addressed by chat_id (a numeric id or @channelusername the bot can reach), shown for up to 5 seconds. Use just before a slower action to signal the bot is working; it sends no message and produces no persistent content. Not idempotent: each call re-broadcasts the status.',
+    idempotent: false,
+  },
+  outputSchema: telegramSendChatActionActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    action: Property.StaticDropdown({
+      displayName: 'Action',
+      description: 'Type of action to broadcast.',
+      required: true,
+      options: {
+        options: [
+          { label: 'Typing', value: 'typing' },
+          { label: 'Upload Photo', value: 'upload_photo' },
+          { label: 'Record Video', value: 'record_video' },
+          { label: 'Upload Video', value: 'upload_video' },
+          { label: 'Record Voice', value: 'record_voice' },
+          { label: 'Upload Voice', value: 'upload_voice' },
+          { label: 'Upload Document', value: 'upload_document' },
+          { label: 'Choose Sticker', value: 'choose_sticker' },
+          { label: 'Find Location', value: 'find_location' },
+          { label: 'Record Video Note', value: 'record_video_note' },
+          { label: 'Upload Video Note', value: 'upload_video_note' },
+        ],
+      },
+      defaultValue: 'typing',
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+  },
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendChatAction'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        action: ctx.propsValue.action,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+      },
+    });
+  },
+});

package/src/lib/action/telegram-send-document.ts

@@ -0,0 +1,136 @@
+import {
+  ApFile,
+  createAction,
+  Property,
+} from '@agnocon/pieces-framework';
+import {
+  HttpMessageBody,
+  HttpMethod,
+  httpClient,
+} from '@agnocon/pieces-common';
+import FormData from 'form-data';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendDocumentActionOutputSchema } from '../output-schemas';
+
+export const telegramSendDocument = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_document',
+  displayName: 'Send Document',
+  description: 'Send a generic file (document) to a Telegram chat.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Uploads and sends a generic file (up to 50 MB) as a document to a chat (chat_id is a numeric id or @channelusername the bot can reach), supplied as an uploaded file OR a previously uploaded file_id. Provide exactly one of document or document_id. Use for arbitrary attachments (PDF, archive, spreadsheet); for media shown inline use telegram_send_photo_or_video, for music use telegram_send_audio. Caption format defaults to plain text. Not idempotent: each call sends a new document.',
+    idempotent: false,
+  },
+  outputSchema: telegramSendDocumentActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    document: Property.File({
+      displayName: 'Document',
+      description:
+        'The document file to send. Telegram supports any file up to 50 MB. Provide this or a document_id.',
+      required: false,
+    }),
+    document_id: Property.ShortText({
+      displayName: 'Document Id',
+      description:
+        'Reuse a document previously uploaded to Telegram by passing its file_id. Provide this or a document file.',
+      required: false,
+    }),
+    caption: Property.LongText({
+      displayName: 'Caption',
+      description: 'Optional caption to display below the document (0–1024 chars).',
+      required: false,
+    }),
+    format: Property.StaticDropdown({
+      displayName: 'Caption Format',
+      description:
+        'How the caption should be parsed by Telegram. Defaults to plain text; only set MarkdownV2 or HTML when the caption is correctly escaped/tagged.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Plain Text', value: 'None' },
+          { label: 'Markdown (V2)', value: 'MarkdownV2' },
+          { label: 'HTML', value: 'HTML' },
+        ],
+      },
+      defaultValue: 'None',
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: Property.Json({
+      displayName: 'Reply Markup',
+      description:
+        'Advanced/optional. A raw JSON-serialized inline keyboard, e.g. {"inline_keyboard":[[{"text":"Open","url":"https://example.com"}]]}. Malformed markup is rejected by Telegram.',
+      required: false,
+    }),
+  },
+  async run(ctx) {
+    const file = ctx.propsValue.document as ApFile | undefined;
+    const documentId = ctx.propsValue.document_id;
+    const parseMode = telegramCommons.resolveParseMode(ctx.propsValue.format);
+
+    if (!file && !documentId) {
+      throw new Error(
+        'Either a document file or a document id must be provided.'
+      );
+    }
+
+    const headers: Record<string, string> = {};
+    let body: HttpMessageBody;
+
+    if (file && file.data && file.filename) {
+      const form = new FormData();
+      form.append('document', file.data, file.filename);
+      form.append('chat_id', ctx.propsValue.chat_id);
+      if (ctx.propsValue.caption) form.append('caption', ctx.propsValue.caption);
+      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_to_message_id) {
+        form.append(
+          'reply_to_message_id',
+          String(ctx.propsValue.reply_to_message_id)
+        );
+      }
+      if (ctx.propsValue.reply_markup) {
+        form.append('reply_markup', JSON.stringify(ctx.propsValue.reply_markup));
+      }
+      body = form;
+      Object.assign(headers, form.getHeaders());
+    } else {
+      body = {
+        chat_id: ctx.propsValue.chat_id,
+        document: documentId,
+        caption: ctx.propsValue.caption ?? 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_to_message_id: ctx.propsValue.reply_to_message_id ?? undefined,
+        reply_markup: ctx.propsValue.reply_markup ?? undefined,
+      };
+    }
+
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'sendDocument'),
+      headers,
+      body,
+    });
+  },
+});

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

@@ -0,0 +1,89 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendLocationActionOutputSchema } from '../output-schemas';
+
+export const telegramSendLocation = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_location',
+  displayName: 'Send Location',
+  description: 'Send a geographic location (latitude/longitude) to a Telegram chat.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Sends a point location (latitude + longitude) to a chat addressed by chat_id (a numeric id or @channelusername the bot can reach), 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,
+  },
+  outputSchema: telegramSendLocationActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    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,
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: Property.Json({
+      displayName: 'Reply Markup',
+      description:
+        'Advanced/optional. A raw JSON-serialized inline keyboard, e.g. {"inline_keyboard":[[{"text":"Open","url":"https://example.com"}]]}. Malformed markup is rejected by Telegram.',
+      required: false,
+    }),
+  },
+  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/telegram-send-media-group.ts

@@ -0,0 +1,119 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendMediaGroupActionOutputSchema } from '../output-schemas';
+
+const MEDIA_GROUP_LIMIT = 10;
+
+type MediaItem = {
+  type: 'photo' | 'video' | 'audio' | 'document';
+  media: string;
+  caption?: string;
+  parse_mode?: string;
+};
+
+export const telegramSendMediaGroup = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_media_group',
+  displayName: 'Send Media Group (Album)',
+  description:
+    'Send a group of 2–10 photos, videos, documents or audios as an album to a chat.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Sends 2–10 media items (each a public URL or a Telegram file_id) as one grouped album to a chat addressed by chat_id (a numeric id or @channelusername the bot can reach). 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. Item captions default to plain text. For a single item use telegram_send_photo_or_video. Not idempotent: each call posts a new album.',
+    idempotent: false,
+  },
+  outputSchema: telegramSendMediaGroupActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    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: Property.StaticDropdown({
+      displayName: 'Caption Format',
+      description:
+        'How item captions should be parsed by Telegram. Defaults to plain text; only set MarkdownV2 or HTML when captions are correctly escaped/tagged.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Plain Text', value: 'None' },
+          { label: 'Markdown (V2)', value: 'MarkdownV2' },
+          { label: 'HTML', value: 'HTML' },
+        ],
+      },
+      defaultValue: 'None',
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+  },
+  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/telegram-send-message.ts

@@ -0,0 +1,79 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { telegramSendMessageActionOutputSchema } from '../output-schemas';
+
+export const telegramSendMessage = createAction({
+  auth: telegramBotAuth,
+  name: 'telegram_send_message',
+  displayName: 'Send Message',
+  description: 'Send a text message to a Telegram chat, group, or channel.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Posts a text message to a Telegram chat, group, or channel addressed by chat_id (a numeric id or @channelusername the bot can reach — resolve via the New Message trigger payload\'s chat.id or telegram_get_chat). Use to deliver a notification, reply, or alert; for an attachment use telegram_send_document, for a photo/video use telegram_send_photo_or_video. Text is sent as plain text unless format is set; if you set MarkdownV2 or HTML the text must be correctly escaped or Telegram rejects it. reply_markup is an advanced raw inline-keyboard JSON object. Not idempotent: each call sends a new message.',
+    idempotent: false,
+  },
+  outputSchema: telegramSendMessageActionOutputSchema,
+  props: {
+    chat_id: telegramCommons.chatIdProp(),
+    message: Property.LongText({
+      displayName: 'Message',
+      description: 'The text message to send.',
+      required: true,
+    }),
+    format: Property.StaticDropdown({
+      displayName: 'Format',
+      description:
+        'How the message text should be parsed by Telegram. Defaults to plain text; only set MarkdownV2 or HTML when the text is correctly escaped/tagged.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Plain Text', value: 'None' },
+          { label: 'Markdown (V2)', value: 'MarkdownV2' },
+          { label: 'HTML', value: 'HTML' },
+        ],
+      },
+      defaultValue: 'None',
+    }),
+    message_thread_id: Property.ShortText({
+      displayName: 'Message Thread Id',
+      description:
+        'Unique identifier for the target message thread of the forum; supergroup forums only.',
+      required: false,
+    }),
+    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(),
+    reply_markup: Property.Json({
+      displayName: 'Reply Markup',
+      description:
+        'Advanced/optional. A raw JSON-serialized inline keyboard or reply keyboard, e.g. {"inline_keyboard":[[{"text":"Open","url":"https://example.com"}]]}. Malformed markup is rejected by Telegram.',
+      required: false,
+    }),
+  },
+  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,
+      },
+    });
+  },
+});