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

package/src/lib/action/forward-message.action.ts

@@ -0,0 +1,50 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { forwardMessageActionOutputSchema } from '../output-schemas';
+
+export const telegramForwardMessageAction = createAction({
+  auth: telegramBotAuth,
+  name: 'forward_message',
+  displayName: 'Forward Message',
+  description: 'Forward a message from one chat to another',
+  audience: 'human',
+  aiMetadata: { description: 'Forwards an existing message from a source chat (from_chat_id) to a target chat (chat_id), preserving its original sender attribution. Use to relay content the bot can access between chats. Not idempotent: each call creates a new forwarded message in the target chat.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: Property.ShortText({
+      displayName: 'Target Chat Id',
+      description: 'Chat the message will be forwarded to.',
+      required: true,
+    }),
+    from_chat_id: Property.ShortText({
+      displayName: 'From Chat Id',
+      description: 'Chat the original message came from.',
+      required: true,
+    }),
+    message_id: Property.Number({
+      displayName: 'Message Id',
+      description: 'Identifier of the message to forward.',
+      required: true,
+    }),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+  },
+  outputSchema: forwardMessageActionOutputSchema,
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'forwardMessage'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        from_chat_id: ctx.propsValue.from_chat_id,
+        message_id: ctx.propsValue.message_id,
+        message_thread_id: ctx.propsValue.message_thread_id ?? undefined,
+        disable_notification: ctx.propsValue.disable_notification ?? false,
+        protect_content: ctx.propsValue.protect_content ?? false,
+      },
+    });
+  },
+});

package/src/lib/action/get-chat-member.ts

@@ -0,0 +1,40 @@
+import { httpClient, HttpError, HttpMethod } from '@agnocon/pieces-common';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { telegramBotAuth } from '../..';
+import { telegramCommons } from '../common';
+import { getChatMemberActionOutputSchema } from '../output-schemas';
+
+export const telegramGetChatMemberAction = createAction({
+  auth: telegramBotAuth,
+  name: 'get_chat_member',
+  description: 'Get member info (or null) for the provided chat id and user id',
+  audience: 'human',
+  aiMetadata: { description: 'Looks up a specific user\'s membership in a chat by chat_id and user_id, returning their role and status (member, administrator, left, kicked, etc.). Use to check whether a user belongs to a chat or what permissions they hold before acting. Idempotent: read-only lookup with no side effects.', idempotent: true },
+  displayName: 'Get Chat Member',
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    user_id: Property.ShortText({
+      displayName: 'User Id',
+      description: 'Unique identifier for the user',
+      required: true,
+    }),
+  },
+  outputSchema: getChatMemberActionOutputSchema,
+  async run(ctx) {
+    try {
+      const response = await httpClient.sendRequest<never>({
+        method: HttpMethod.POST,
+        url: telegramCommons.getApiUrl(ctx.auth, 'getChatMember'),
+        headers: {},
+        body: {
+          chat_id: ctx.propsValue.chat_id,
+          user_id: ctx.propsValue.user_id,
+        },
+      });
+      return response.body;
+    } catch (error) {
+      return (error as HttpError).errorMessage().response.body;
+    }
+  },
+});

package/src/lib/action/get-chat.action.ts

@@ -0,0 +1,33 @@
+import { HttpError, HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { createAction } from '@agnocon/pieces-framework';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { getChatActionOutputSchema } from '../output-schemas';
+
+export const telegramGetChatAction = createAction({
+  auth: telegramBotAuth,
+  name: 'get_chat',
+  displayName: 'Get Chat',
+  description: 'Get up-to-date information about a chat (name, description, photo, member count, etc.)',
+  audience: 'human',
+  aiMetadata: { description: 'Looks up current details about a chat (title, description, type, photo, member count, etc.) by chat_id. Use to resolve or inspect a chat before acting on it; the bot must be a member of or have access to the chat. Idempotent: read-only lookup with no side effects.', idempotent: true },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+  },
+  outputSchema: getChatActionOutputSchema,
+  async run(ctx) {
+    try {
+      const response = await httpClient.sendRequest<never>({
+        method: HttpMethod.POST,
+        url: telegramCommons.getApiUrl(ctx.auth, 'getChat'),
+        body: {
+          chat_id: ctx.propsValue.chat_id,
+        },
+      });
+      return response.body;
+    } catch (error) {
+      return (error as HttpError).errorMessage().response.body;
+    }
+  },
+});

package/src/lib/action/get-file.action.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 { getFileActionOutputSchema } from '../output-schemas';
+
+type TelegramFileInfo = {
+  file_id: string;
+  file_unique_id: string;
+  file_size?: number;
+  file_path?: string;
+};
+
+type TelegramGetFileResponse = {
+  ok: boolean;
+  result: TelegramFileInfo;
+};
+
+export const telegramGetFileAction = createAction({
+  auth: telegramBotAuth,
+  name: 'get_file',
+  description: 'Get file information and optionally download a file from Telegram',
+  audience: 'human',
+  aiMetadata: { description: 'Resolves a Telegram file_id to its file metadata and download URL, and optionally downloads the file content as base64 when download is enabled. Use to retrieve files attached to messages the bot received. Idempotent: read/download with no side effects, though Telegram download URLs are time-limited.', idempotent: true },
+  displayName: 'Get File',
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description: 'File identifier to get information about',
+      required: true,
+    }),
+    download: Property.Checkbox({
+      displayName: 'Download File',
+      description: 'If enabled, the file is downloaded and returned as base64.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  outputSchema: getFileActionOutputSchema,
+  async run(ctx) {
+    const fileInfoResponse = await httpClient.sendRequest<TelegramGetFileResponse>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'getFile'),
+      body: {
+        file_id: ctx.propsValue.file_id,
+      },
+    });
+
+    if (!fileInfoResponse.body.ok) {
+      throw new Error(`Failed to get file info: ${JSON.stringify(fileInfoResponse.body)}`);
+    }
+
+    const fileInfo = fileInfoResponse.body.result;
+    const fileUrl = fileInfo.file_path
+      ? `https://api.telegram.org/file/bot${ctx.auth.secret_text}/${fileInfo.file_path}`
+      : undefined;
+
+    if (ctx.propsValue.download && fileUrl) {
+      const fileResponse = await httpClient.sendRequest<Buffer>({
+        method: HttpMethod.GET,
+        url: fileUrl,
+        responseType: 'arraybuffer',
+      });
+
+      const base64Content = Buffer.from(fileResponse.body).toString('base64');
+
+      return {
+        file_info: fileInfo,
+        file_url: fileUrl,
+        file_content_base64: base64Content,
+      };
+    }
+
+    return {
+      file_info: fileInfo,
+      file_url: fileUrl,
+    };
+  },
+});

package/src/lib/action/pin-message.action.ts

@@ -0,0 +1,41 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { pinMessageActionOutputSchema } from '../output-schemas';
+
+export const telegramPinMessageAction = createAction({
+  auth: telegramBotAuth,
+  name: 'pin_message',
+  displayName: 'Pin Message',
+  description: 'Pin a message in a chat. The bot must be an administrator in the chat for this to work.',
+  audience: 'human',
+  aiMetadata: { description: 'Pins an existing message in a chat, identified by chat_id and message_id; the bot must be an administrator with pin rights. Use to highlight an announcement or important message. Idempotent: pinning an already-pinned message leaves it pinned with the same result.', idempotent: true },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_id: Property.Number({
+      displayName: 'Message Id',
+      description: 'Identifier of the message to pin.',
+      required: true,
+    }),
+    disable_notification: Property.Checkbox({
+      displayName: 'Disable Notification',
+      description: 'Pass True if it is not necessary to send a notification to all chat members.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  outputSchema: pinMessageActionOutputSchema,
+  async run(ctx) {
+    return await httpClient.sendRequest<never>({
+      method: HttpMethod.POST,
+      url: telegramCommons.getApiUrl(ctx.auth, 'pinChatMessage'),
+      body: {
+        chat_id: ctx.propsValue.chat_id,
+        message_id: ctx.propsValue.message_id,
+        disable_notification: ctx.propsValue.disable_notification ?? false,
+      },
+    });
+  },
+});

package/src/lib/action/request-approval-message.ts

@@ -0,0 +1,85 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { assertNotNullOrUndefined } from '@agnocon/pieces-framework';
+import { ExecutionType } from '@agnocon/pieces-framework';
+import { requestApprovalMessageActionOutputSchema } from '../output-schemas';
+
+export const telegramRequestApprovalMessageAction = createAction({
+  auth: telegramBotAuth,
+  name: 'request_approval_message',
+  displayName: 'Request Approval Message',
+  description:
+    'Send an approval message to a chat and wait until the message is approved or disapproved',
+  audience: 'both',
+  aiMetadata: { description: 'Sends a message with a single button linking to a confirmation page where the recipient chooses Approve or Disapprove, then pauses the flow until they respond and resumes with the decision. Use as a human approval gate before a sensitive downstream step. Not idempotent: each call sends a new message and opens a new pause/wait.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message: Property.LongText({
+      displayName: 'Message',
+      description: 'The approval message to be sent',
+      required: true,
+    }),
+    parse_mode: telegramCommons.parseModeProp(),
+  },
+  outputSchema: requestApprovalMessageActionOutputSchema,
+  async run(context) {
+    if (context.executionType === ExecutionType.BEGIN) {
+      const token = context.auth.secret_text;
+      const { chat_id, message, parse_mode } = context.propsValue;
+
+      assertNotNullOrUndefined(token, 'token');
+      assertNotNullOrUndefined(message, 'message');
+      assertNotNullOrUndefined(chat_id, 'chat_id');
+
+      // Generate approval and disapproval links
+      const waitpoint = await context.run.createWaitpoint({
+        type: 'WEBHOOK',
+      });
+      const confirmationLink = `${waitpoint.resumeUrl}/confirm?chat_id=${encodeURIComponent(chat_id)}`;
+
+      // Send message with a single button opening the confirmation page (the recipient
+      // chooses Approve/Disapprove there). A single link keeps the message-preview
+      // prefetch from consuming the waitpoint.
+      const response = await httpClient.sendRequest<{
+        ok: boolean;
+        result: { message_id: number };
+      }>({
+        method: HttpMethod.POST,
+        url: telegramCommons.getApiUrl(context.auth, 'sendMessage'),
+        body: {
+          chat_id,
+          text: message,
+          parse_mode: telegramCommons.resolveParseMode(parse_mode),
+          reply_markup: {
+            inline_keyboard: [
+              [
+                {
+                  text: 'Review & Respond',
+                  url: confirmationLink,
+                },
+              ],
+            ],
+          },
+        },
+      });
+
+      const messageId = response.body.result.message_id;
+
+      context.run.waitForWaitpoint(waitpoint.id);
+
+      return {
+        approved: false, // default approval is false
+        messageId,
+        chatId: chat_id,
+      };
+    } else {
+      return {
+        approved: context.resumePayload.queryParams['action'] === 'approve',
+        chatId: context.resumePayload.queryParams['chat_id'],
+      };
+    }
+  },
+});

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

@@ -0,0 +1,123 @@
+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 { sendAudioActionOutputSchema } from '../output-schemas';
+
+export const telegramSendAudioAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_audio',
+  displayName: 'Send Audio',
+  description: 'Send an audio file to a Telegram chat (.MP3/.M4A — shown in the music player)',
+  audience: 'human',
+  aiMetadata: { description: 'Sends an audio file (.MP3/.M4A) to a Telegram chat where it appears in the music player, supplied as a file or a previously uploaded file_id, with optional performer and track title. Use for music or audio tracks; for raw file attachments use Send Document. Not idempotent: each call sends a new message.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    audio: Property.File({
+      displayName: 'Audio',
+      description: 'The audio file to send (.MP3 or .M4A).',
+      required: false,
+    }),
+    audio_id: Property.ShortText({
+      displayName: 'Audio Id',
+      description: 'Reuse an audio file previously uploaded to Telegram by passing its file_id.',
+      required: false,
+    }),
+    caption: Property.LongText({
+      displayName: 'Caption',
+      description: 'Optional caption (0–1024 chars).',
+      required: false,
+    }),
+    format: telegramCommons.parseModeProp(),
+    instructions_format: telegramCommons.formatLinkInstructions(),
+    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,
+    }),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendAudioActionOutputSchema,
+  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/send-chat-action.action.ts

@@ -0,0 +1,53 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { telegramCommons } from '../common';
+import { telegramBotAuth } from '../..';
+import { sendChatActionActionOutputSchema } from '../output-schemas';
+
+export const telegramSendChatActionAction = createAction({
+  auth: telegramBotAuth,
+  name: '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: 'human',
+  aiMetadata: { description: 'Broadcasts a transient activity status (such as typing or uploading photo) in a chat, 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 },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    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',
+    }),
+  },
+  outputSchema: sendChatActionActionOutputSchema,
+  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/send-document.action.ts

@@ -0,0 +1,105 @@
+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 { sendDocumentActionOutputSchema } from '../output-schemas';
+
+export const telegramSendDocumentAction = createAction({
+  auth: telegramBotAuth,
+  name: 'send_document',
+  displayName: 'Send Document',
+  description: 'Send a generic file (document) to a Telegram chat',
+  audience: 'human',
+  aiMetadata: { description: 'Uploads and sends a generic file (up to 50 MB) as a document to a Telegram chat, supplied as a file or a previously uploaded Telegram file_id. Use for arbitrary attachments (PDFs, archives, spreadsheets) rather than media shown inline. Not idempotent: each call sends a new document.', idempotent: false },
+  props: {
+    instructions: telegramCommons.chatIdInstructions(),
+    chat_id: telegramCommons.chatIdProp(),
+    message_thread_id: telegramCommons.messageThreadIdProp(),
+    document: Property.File({
+      displayName: 'Document',
+      description: 'The document file to send. Telegram supports any file up to 50 MB.',
+      required: false,
+    }),
+    document_id: Property.ShortText({
+      displayName: 'Document Id',
+      description:
+        'Reuse a document previously uploaded to Telegram by passing its file_id. Either provide a document or a document id.',
+      required: false,
+    }),
+    caption: Property.LongText({
+      displayName: 'Caption',
+      description: 'Optional caption to display below the document (0–1024 chars).',
+      required: false,
+    }),
+    format: telegramCommons.parseModeProp(),
+    instructions_format: telegramCommons.formatLinkInstructions(),
+    disable_notification: telegramCommons.disableNotificationProp(),
+    protect_content: telegramCommons.protectContentProp(),
+    reply_to_message_id: telegramCommons.replyToMessageIdProp(),
+    reply_markup: telegramCommons.replyMarkupProp(),
+  },
+  outputSchema: sendDocumentActionOutputSchema,
+  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,
+    });
+  },
+});