@mtcute/core 0.30.0 → 0.30.2

package/highlevel/methods/files/normalize-input-media.js

@@ -10,7 +10,7 @@ import { _normalizeInputText } from "../misc/normalize-text.js";
 import { resolvePeer } from "../users/resolve-peer.js";
 import { _normalizeInputFile } from "./normalize-input-file.js";
 import { uploadFile } from "./upload-file.js";
-import { isAnyInputMedia, isAnyPollAnswer, isAnyInputFile } from "../../../tl/inner-tl.js";
+import { isAnyInputMedia, isAnyInputPhoto, isAnyInputDocument, isAnyPollAnswer, isAnyInputFile } from "../../../tl/inner-tl.js";
 async function _normalizeInputMedia(client, media, params = {}, uploadMedia = false) {
   if (isAnyInputMedia(media)) {
     switch (media._) {
@@ -22,6 +22,14 @@ async function _normalizeInputMedia(client, media, params = {}, uploadMedia = fa
     }
     return media;
   }
+  if (isAnyInputPhoto(media)) {
+    assertTypeIs("normalizeInputMedia (@ photo)", media, "inputPhoto");
+    return { _: "inputMediaPhoto", id: media };
+  }
+  if (isAnyInputDocument(media)) {
+    assertTypeIs("normalizeInputMedia (@ document)", media, "inputDocument");
+    return { _: "inputMediaDocument", id: media };
+  }
   if (media.type === "venue") {
     return {
       _: "inputMediaVenue",
@@ -268,7 +276,7 @@ async function _normalizeInputMedia(client, media, params = {}, uploadMedia = fa
           fileReference: res.photo.fileReference
         },
         ttlSeconds: media.ttlSeconds,
-        spoiler: media.type === "video" && media.spoiler,
+        spoiler: "spoiler" in media ? media.spoiler : false,
         livePhoto: Boolean(livePhotoVideo),
         video: livePhotoVideo
       };

package/highlevel/methods/files/upload-file.cjs

@@ -174,7 +174,12 @@ async function uploadFile(client, params) {
       filePart: thisIdx,
       bytes: part
     };
-    const result = await client.call(request, { kind: connectionKind, abortSignal });
+    const result = await client.call(request, {
+      kind: connectionKind,
+      maxRetryCount: Infinity,
+      floodSleepThreshold: Infinity,
+      abortSignal
+    });
     if (!result) throw new Error(`Failed to upload part ${idx}`);
     if (abortSignal?.aborted) return;
     pos += part.length;

package/highlevel/methods/files/upload-file.js

@@ -167,7 +167,12 @@ async function uploadFile(client, params) {
       filePart: thisIdx,
       bytes: part
     };
-    const result = await client.call(request, { kind: connectionKind, abortSignal });
+    const result = await client.call(request, {
+      kind: connectionKind,
+      maxRetryCount: Infinity,
+      floodSleepThreshold: Infinity,
+      abortSignal
+    });
     if (!result) throw new Error(`Failed to upload part ${idx}`);
     if (abortSignal?.aborted) return;
     pos += part.length;

package/highlevel/methods/messages/create-rich-streaming-draft.cjs

@@ -0,0 +1,39 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const longUtils = require("../../../utils/long-utils.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const normalizeRichMessage = require("./normalize-rich-message.cjs");
+async function createRichStreamingDraft(client, chatId, params) {
+  const { threadId, businessConnectionId, progressCallback } = params ?? {};
+  const randomId = longUtils.randomLong();
+  const peer = await resolvePeer.resolvePeer(client, chatId);
+  const uploadCache = params?.disableUploadCache ? void 0 : /* @__PURE__ */ new Map();
+  const sendDraft = async (content) => {
+    const richMessage = await normalizeRichMessage._normalizeInputRichMessage(client, peer, content, { progressCallback, uploadCache });
+    const r = await client.call({
+      _: "messages.setTyping",
+      peer,
+      action: {
+        _: "inputSendMessageRichMessageDraftAction",
+        randomId,
+        richMessage
+      },
+      topMsgId: threadId
+    }, {
+      businessConnectionId
+    });
+    typeAssertions.assertTrue("messages.setTyping", r);
+  };
+  return {
+    randomId,
+    send: sendDraft,
+    uploadCache
+  };
+}
+exports.createRichStreamingDraft = createRichStreamingDraft;

package/highlevel/methods/messages/create-rich-streaming-draft.d.cts

@@ -0,0 +1,42 @@
+import { default as Long } from 'long';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+export interface RichStreamingDraft {
+    /** Random ID of the draft */
+    readonly randomId: Long;
+    /** Replace the draft with the given rich message */
+    send(content: InputRichMessage): Promise<void>;
+    /**
+     * Cache of media uploaded while streaming the draft (unless disabled).
+     *
+     * Pass it to the final {@link sendRichMessage} call to avoid re-uploading the media.
+     */
+    readonly uploadCache?: RichMediaUploadCache;
+}
+/**
+ * Create a streaming rich message draft
+ *
+ * @param chatId  Chat ID
+ * @param params
+ */
+export declare function createRichStreamingDraft(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Unique identifier of the business connection on behalf of which the action will be sent
+     */
+    businessConnectionId?: string;
+    /** Whether to disable upload cache (exists to prevent uploading the same media multiple times) */
+    disableUploadCache?: boolean;
+    /**
+     * For comment threads, ID of the thread (i.e. top message)
+     */
+    threadId?: number;
+    /**
+     * Function that will be called after some part of the media has been uploaded.
+     *
+     * @param id  ID of the file being uploaded
+     * @param uploaded  Number of bytes already uploaded
+     * @param total  Total file size
+     */
+    progressCallback?: (id: string, uploaded: number, total: number) => void;
+}): Promise<RichStreamingDraft>;

package/highlevel/methods/messages/create-rich-streaming-draft.d.ts

@@ -0,0 +1,42 @@
+import { default as Long } from 'long';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+export interface RichStreamingDraft {
+    /** Random ID of the draft */
+    readonly randomId: Long;
+    /** Replace the draft with the given rich message */
+    send(content: InputRichMessage): Promise<void>;
+    /**
+     * Cache of media uploaded while streaming the draft (unless disabled).
+     *
+     * Pass it to the final {@link sendRichMessage} call to avoid re-uploading the media.
+     */
+    readonly uploadCache?: RichMediaUploadCache;
+}
+/**
+ * Create a streaming rich message draft
+ *
+ * @param chatId  Chat ID
+ * @param params
+ */
+export declare function createRichStreamingDraft(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Unique identifier of the business connection on behalf of which the action will be sent
+     */
+    businessConnectionId?: string;
+    /** Whether to disable upload cache (exists to prevent uploading the same media multiple times) */
+    disableUploadCache?: boolean;
+    /**
+     * For comment threads, ID of the thread (i.e. top message)
+     */
+    threadId?: number;
+    /**
+     * Function that will be called after some part of the media has been uploaded.
+     *
+     * @param id  ID of the file being uploaded
+     * @param uploaded  Number of bytes already uploaded
+     * @param total  Total file size
+     */
+    progressCallback?: (id: string, uploaded: number, total: number) => void;
+}): Promise<RichStreamingDraft>;

package/highlevel/methods/messages/create-rich-streaming-draft.js

@@ -0,0 +1,34 @@
+import { randomLong } from "../../../utils/long-utils.js";
+import { assertTrue } from "../../../utils/type-assertions.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+import { _normalizeInputRichMessage } from "./normalize-rich-message.js";
+async function createRichStreamingDraft(client, chatId, params) {
+  const { threadId, businessConnectionId, progressCallback } = params ?? {};
+  const randomId = randomLong();
+  const peer = await resolvePeer(client, chatId);
+  const uploadCache = params?.disableUploadCache ? void 0 : /* @__PURE__ */ new Map();
+  const sendDraft = async (content) => {
+    const richMessage = await _normalizeInputRichMessage(client, peer, content, { progressCallback, uploadCache });
+    const r = await client.call({
+      _: "messages.setTyping",
+      peer,
+      action: {
+        _: "inputSendMessageRichMessageDraftAction",
+        randomId,
+        richMessage
+      },
+      topMsgId: threadId
+    }, {
+      businessConnectionId
+    });
+    assertTrue("messages.setTyping", r);
+  };
+  return {
+    randomId,
+    send: sendDraft,
+    uploadCache
+  };
+}
+export {
+  createRichStreamingDraft
+};

package/highlevel/methods/messages/normalize-rich-message.cjs

@@ -0,0 +1,168 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const errors = require("../../../types/errors.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const walkPageBlocks = require("../../utils/walk-page-blocks.cjs");
+const normalizeInputMedia = require("../files/normalize-input-media.cjs");
+const resolvePeerMany = require("../users/resolve-peer-many.cjs");
+function _richMediaCacheKey(media) {
+  if (typeof media === "string") return `auto:${media}`;
+  if ("_" in media) return void 0;
+  if (typeof media.file === "string") return `${media.type}:${media.file}`;
+  return media;
+}
+async function _uploadRichMedia(client, peer, id, media, params) {
+  const cacheKey = params.uploadCache != null ? _richMediaCacheKey(media) : void 0;
+  if (cacheKey !== void 0) {
+    const cached = params.uploadCache.get(cacheKey);
+    if (cached != null) return cached;
+  }
+  const input = typeof media === "string" ? { type: "auto", file: media } : media;
+  const normalized = await normalizeInputMedia._normalizeInputMedia(client, input, {
+    uploadPeer: peer,
+    abortSignal: params.abortSignal,
+    progressCallback: params.progressCallback?.bind(null, id)
+  }, true);
+  if (normalized._ !== "inputMediaPhoto" && normalized._ !== "inputMediaDocument") {
+    throw new errors.MtTypeAssertionError("sendRichMessage (upload)", "inputMediaDocument | inputMediaPhoto", normalized._);
+  }
+  if (cacheKey !== void 0) params.uploadCache.set(cacheKey, normalized);
+  return normalized;
+}
+async function _normalizeInputRichMessage(client, peer, input, params) {
+  if ("_" in input) return input;
+  if (input.type !== "blocks") {
+    let richFiles;
+    if (input.attachments) {
+      const medias = [...Object.entries(input.attachments)];
+      const normalized = await utils.parallelMap(
+        medias,
+        async ([id, media]) => [id, await _uploadRichMedia(client, peer, id, media, params)],
+        { limit: 4, signal: params.abortSignal }
+      );
+      richFiles = normalized.map(
+        ([id, media]) => media._ === "inputMediaDocument" ? { _: "inputRichFileDocument", id, document: media.id } : { _: "inputRichFilePhoto", id, photo: media.id }
+      );
+    }
+    return input.type === "markdown" ? {
+      _: "inputRichMessageMarkdown",
+      rtl: input.rtl,
+      noautolink: input.skipEntityDetection,
+      files: richFiles,
+      markdown: input.content
+    } : {
+      _: "inputRichMessageHTML",
+      rtl: input.rtl,
+      noautolink: input.skipEntityDetection,
+      files: richFiles,
+      html: input.content
+    };
+  }
+  const photos = [];
+  const documents = [];
+  const fileBlocks = [];
+  function processBlock(node) {
+    if ("file" in node) {
+      const block = processBlock(node.block);
+      fileBlocks.push({ block, media: node.file });
+      return block;
+    }
+    switch (node._) {
+      case "pageBlockCover":
+        return { ...node, cover: processBlock(node.cover) };
+      case "pageBlockCollage":
+      case "pageBlockSlideshow":
+        return { ...node, items: node.items.map(processBlock) };
+      case "pageBlockDetails":
+      case "pageBlockEmbedPost":
+      case "pageBlockBlockquoteBlocks":
+        return { ...node, blocks: node.blocks.map(processBlock) };
+      case "pageBlockList":
+        return {
+          ...node,
+          items: node.items.map(
+            (item) => item._ === "pageListItemBlocks" ? {
+              ...item,
+              blocks: item.blocks.map(processBlock)
+            } : item
+          )
+        };
+      case "pageBlockOrderedList":
+        return {
+          ...node,
+          items: node.items.map(
+            (item) => item._ === "pageListOrderedItemBlocks" ? { ...item, blocks: item.blocks.map(processBlock) } : item
+          )
+        };
+      default:
+        return node;
+    }
+  }
+  const blocks = input.blocks.map(processBlock);
+  const mentionIds = /* @__PURE__ */ new Set();
+  walkPageBlocks.walkPageBlocks(blocks, {
+    richText: (text) => {
+      if (text._ === "textMentionName") mentionIds.add(text.userId);
+    }
+  });
+  const users = mentionIds.size ? await resolvePeerMany.resolvePeerMany(client, [...mentionIds], peerUtils.toInputUser) : void 0;
+  const uploaded = await utils.parallelMap(
+    fileBlocks,
+    async ({ block, media }, idx) => {
+      const uploaded2 = await _uploadRichMedia(client, peer, `block-${idx}`, media, params);
+      return { block, media: uploaded2 };
+    },
+    { limit: 4, signal: params.abortSignal }
+  );
+  for (const { block, media } of uploaded) {
+    if (media._ === "inputMediaPhoto") {
+      const photo = media.id;
+      typeAssertions.assertTypeIs("sendRichMessage (upload)", photo, "inputPhoto");
+      photos.push(photo);
+      switch (block._) {
+        case "pageBlockPhoto":
+          block.photoId = photo.id;
+          break;
+        case "pageBlockEmbed":
+          block.posterPhotoId = photo.id;
+          break;
+        case "pageBlockEmbedPost":
+          block.authorPhotoId = photo.id;
+          break;
+        default:
+          throw new errors.MtArgumentError(`sendRichMessage: expected photo ${photo.id} to be used in a photo block, but got ${block._}`);
+      }
+    } else {
+      const document = media.id;
+      typeAssertions.assertTypeIs("sendRichMessage (upload)", document, "inputDocument");
+      documents.push(document);
+      switch (block._) {
+        case "pageBlockVideo":
+          block.videoId = document.id;
+          break;
+        case "pageBlockAudio":
+          block.audioId = document.id;
+          break;
+        default:
+          throw new errors.MtArgumentError(`sendRichMessage: expected document ${document.id} to be used in a document block, but got ${block._}`);
+      }
+    }
+  }
+  return {
+    _: "inputRichMessage",
+    rtl: input.rtl,
+    noautolink: input.skipEntityDetection,
+    blocks,
+    photos: photos.length ? photos : void 0,
+    documents: documents.length ? documents : void 0,
+    users: users?.length ? users : void 0
+  };
+}
+exports._normalizeInputRichMessage = _normalizeInputRichMessage;

package/highlevel/methods/messages/normalize-rich-message.d.cts

@@ -0,0 +1,10 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+interface NormalizeRichMessageParams {
+    abortSignal?: AbortSignal;
+    progressCallback?: (id: string, uploaded: number, total: number) => void;
+    uploadCache?: RichMediaUploadCache;
+}
+export declare function _normalizeInputRichMessage(client: ITelegramClient, peer: tl.TypeInputPeer, input: InputRichMessage, params: NormalizeRichMessageParams): Promise<tl.TypeInputRichMessage>;
+export {};

package/highlevel/methods/messages/normalize-rich-message.d.ts

@@ -0,0 +1,10 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+interface NormalizeRichMessageParams {
+    abortSignal?: AbortSignal;
+    progressCallback?: (id: string, uploaded: number, total: number) => void;
+    uploadCache?: RichMediaUploadCache;
+}
+export declare function _normalizeInputRichMessage(client: ITelegramClient, peer: tl.TypeInputPeer, input: InputRichMessage, params: NormalizeRichMessageParams): Promise<tl.TypeInputRichMessage>;
+export {};

package/highlevel/methods/messages/normalize-rich-message.js

@@ -0,0 +1,163 @@
+import { parallelMap } from "@fuman/utils";
+import { MtArgumentError, MtTypeAssertionError } from "../../../types/errors.js";
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { toInputUser } from "../../utils/peer-utils.js";
+import { walkPageBlocks } from "../../utils/walk-page-blocks.js";
+import { _normalizeInputMedia } from "../files/normalize-input-media.js";
+import { resolvePeerMany } from "../users/resolve-peer-many.js";
+function _richMediaCacheKey(media) {
+  if (typeof media === "string") return `auto:${media}`;
+  if ("_" in media) return void 0;
+  if (typeof media.file === "string") return `${media.type}:${media.file}`;
+  return media;
+}
+async function _uploadRichMedia(client, peer, id, media, params) {
+  const cacheKey = params.uploadCache != null ? _richMediaCacheKey(media) : void 0;
+  if (cacheKey !== void 0) {
+    const cached = params.uploadCache.get(cacheKey);
+    if (cached != null) return cached;
+  }
+  const input = typeof media === "string" ? { type: "auto", file: media } : media;
+  const normalized = await _normalizeInputMedia(client, input, {
+    uploadPeer: peer,
+    abortSignal: params.abortSignal,
+    progressCallback: params.progressCallback?.bind(null, id)
+  }, true);
+  if (normalized._ !== "inputMediaPhoto" && normalized._ !== "inputMediaDocument") {
+    throw new MtTypeAssertionError("sendRichMessage (upload)", "inputMediaDocument | inputMediaPhoto", normalized._);
+  }
+  if (cacheKey !== void 0) params.uploadCache.set(cacheKey, normalized);
+  return normalized;
+}
+async function _normalizeInputRichMessage(client, peer, input, params) {
+  if ("_" in input) return input;
+  if (input.type !== "blocks") {
+    let richFiles;
+    if (input.attachments) {
+      const medias = [...Object.entries(input.attachments)];
+      const normalized = await parallelMap(
+        medias,
+        async ([id, media]) => [id, await _uploadRichMedia(client, peer, id, media, params)],
+        { limit: 4, signal: params.abortSignal }
+      );
+      richFiles = normalized.map(
+        ([id, media]) => media._ === "inputMediaDocument" ? { _: "inputRichFileDocument", id, document: media.id } : { _: "inputRichFilePhoto", id, photo: media.id }
+      );
+    }
+    return input.type === "markdown" ? {
+      _: "inputRichMessageMarkdown",
+      rtl: input.rtl,
+      noautolink: input.skipEntityDetection,
+      files: richFiles,
+      markdown: input.content
+    } : {
+      _: "inputRichMessageHTML",
+      rtl: input.rtl,
+      noautolink: input.skipEntityDetection,
+      files: richFiles,
+      html: input.content
+    };
+  }
+  const photos = [];
+  const documents = [];
+  const fileBlocks = [];
+  function processBlock(node) {
+    if ("file" in node) {
+      const block = processBlock(node.block);
+      fileBlocks.push({ block, media: node.file });
+      return block;
+    }
+    switch (node._) {
+      case "pageBlockCover":
+        return { ...node, cover: processBlock(node.cover) };
+      case "pageBlockCollage":
+      case "pageBlockSlideshow":
+        return { ...node, items: node.items.map(processBlock) };
+      case "pageBlockDetails":
+      case "pageBlockEmbedPost":
+      case "pageBlockBlockquoteBlocks":
+        return { ...node, blocks: node.blocks.map(processBlock) };
+      case "pageBlockList":
+        return {
+          ...node,
+          items: node.items.map(
+            (item) => item._ === "pageListItemBlocks" ? {
+              ...item,
+              blocks: item.blocks.map(processBlock)
+            } : item
+          )
+        };
+      case "pageBlockOrderedList":
+        return {
+          ...node,
+          items: node.items.map(
+            (item) => item._ === "pageListOrderedItemBlocks" ? { ...item, blocks: item.blocks.map(processBlock) } : item
+          )
+        };
+      default:
+        return node;
+    }
+  }
+  const blocks = input.blocks.map(processBlock);
+  const mentionIds = /* @__PURE__ */ new Set();
+  walkPageBlocks(blocks, {
+    richText: (text) => {
+      if (text._ === "textMentionName") mentionIds.add(text.userId);
+    }
+  });
+  const users = mentionIds.size ? await resolvePeerMany(client, [...mentionIds], toInputUser) : void 0;
+  const uploaded = await parallelMap(
+    fileBlocks,
+    async ({ block, media }, idx) => {
+      const uploaded2 = await _uploadRichMedia(client, peer, `block-${idx}`, media, params);
+      return { block, media: uploaded2 };
+    },
+    { limit: 4, signal: params.abortSignal }
+  );
+  for (const { block, media } of uploaded) {
+    if (media._ === "inputMediaPhoto") {
+      const photo = media.id;
+      assertTypeIs("sendRichMessage (upload)", photo, "inputPhoto");
+      photos.push(photo);
+      switch (block._) {
+        case "pageBlockPhoto":
+          block.photoId = photo.id;
+          break;
+        case "pageBlockEmbed":
+          block.posterPhotoId = photo.id;
+          break;
+        case "pageBlockEmbedPost":
+          block.authorPhotoId = photo.id;
+          break;
+        default:
+          throw new MtArgumentError(`sendRichMessage: expected photo ${photo.id} to be used in a photo block, but got ${block._}`);
+      }
+    } else {
+      const document = media.id;
+      assertTypeIs("sendRichMessage (upload)", document, "inputDocument");
+      documents.push(document);
+      switch (block._) {
+        case "pageBlockVideo":
+          block.videoId = document.id;
+          break;
+        case "pageBlockAudio":
+          block.audioId = document.id;
+          break;
+        default:
+          throw new MtArgumentError(`sendRichMessage: expected document ${document.id} to be used in a document block, but got ${block._}`);
+      }
+    }
+  }
+  return {
+    _: "inputRichMessage",
+    rtl: input.rtl,
+    noautolink: input.skipEntityDetection,
+    blocks,
+    photos: photos.length ? photos : void 0,
+    documents: documents.length ? documents : void 0,
+    users: users?.length ? users : void 0
+  };
+}
+export {
+  _normalizeInputRichMessage
+};

package/highlevel/methods/messages/send-common.cjs

@@ -48,11 +48,12 @@ async function _processCommonSendParameters(client, chatId, params) {
     throw new errors.MtArgumentError("replyTo/commentTo and replyToStory cannot be used together");
   }
   let tlReplyTo;
-  if (replyTo) {
+  if (replyTo || params.threadId) {
     tlReplyTo = {
       _: "inputReplyToMessage",
-      replyToMsgId: replyTo,
+      replyToMsgId: replyTo ?? params.threadId,
       replyToPeerId: replyToPeer,
+      topMsgId: params.threadId,
       quoteText: params.quote?.text,
       quoteEntities: params.quote?.entities,
       quoteOffset: params.quoteOffset,

package/highlevel/methods/messages/send-common.d.cts

@@ -7,11 +7,14 @@ export interface CommonSendParams {
     /**
      * Message to reply to. Either a message object or message ID.
      *
-     * For forums - can also be an ID of the topic (i.e. its top message ID)
+     * For forums - can also be an ID of the topic (i.e. its top message ID),
+     * but prefer using {@link threadId} for that instead.
      *
      * Can also be a message from another chat, in which case a quote will be sent.
      */
     replyTo?: number | Message;
+    /** ID of the thread to reply to */
+    threadId?: number;
     /**
      * If this is a reply to a specific todo item, ID of that item
      */

package/highlevel/methods/messages/send-common.d.ts

@@ -7,11 +7,14 @@ export interface CommonSendParams {
     /**
      * Message to reply to. Either a message object or message ID.
      *
-     * For forums - can also be an ID of the topic (i.e. its top message ID)
+     * For forums - can also be an ID of the topic (i.e. its top message ID),
+     * but prefer using {@link threadId} for that instead.
      *
      * Can also be a message from another chat, in which case a quote will be sent.
      */
     replyTo?: number | Message;
+    /** ID of the thread to reply to */
+    threadId?: number;
     /**
      * If this is a reply to a specific todo item, ID of that item
      */

package/highlevel/methods/messages/send-common.js

@@ -41,11 +41,12 @@ async function _processCommonSendParameters(client, chatId, params) {
     throw new MtArgumentError("replyTo/commentTo and replyToStory cannot be used together");
   }
   let tlReplyTo;
-  if (replyTo) {
+  if (replyTo || params.threadId) {
     tlReplyTo = {
       _: "inputReplyToMessage",
-      replyToMsgId: replyTo,
+      replyToMsgId: replyTo ?? params.threadId,
       replyToPeerId: replyToPeer,
+      topMsgId: params.threadId,
       quoteText: params.quote?.text,
       quoteEntities: params.quote?.entities,
       quoteOffset: params.quoteOffset,