@lazyneoaz/metachat 1.0.0

package/src/apis/sendEffect.js

@@ -0,0 +1,311 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * Facebook Messenger send effects — visual animations that play when a message is sent/received.
+ *
+ * Usage:
+ *   api.sendEffect.fire('Hello!', threadID)
+ *   api.sendEffect.send('love', 'Hello!', threadID)
+ *   api.sendEffect.list()  →  [{tag, aliases, emoji}, ...]
+ */
+
+const EFFECTS = {
+  fire:          { tag: 'FIRE',          emoji: '🔥', label: 'Fire' },
+  love:          { tag: 'LOVE',          emoji: '❤️', label: 'Love' },
+  heart:         { tag: 'LOVE',          emoji: '❤️', label: 'Love' },
+  hearts:        { tag: 'LOVE',          emoji: '❤️', label: 'Love' },
+  confetti:      { tag: 'CELEBRATION',   emoji: '🎉', label: 'Confetti' },
+  celebration:   { tag: 'CELEBRATION',   emoji: '🎉', label: 'Confetti' },
+  wand:          { tag: 'WAND',          emoji: '🪄', label: 'Wand' },
+  magic:         { tag: 'WAND',          emoji: '🪄', label: 'Wand' },
+  fireworks:     { tag: 'FIREWORKS',     emoji: '🎆', label: 'Fireworks' },
+  shooting_star: { tag: 'SHOOTING_STAR', emoji: '🌠', label: 'Shooting Star' },
+  stars:         { tag: 'SHOOTING_STAR', emoji: '🌠', label: 'Shooting Star' },
+  starstruck:    { tag: 'SHOOTING_STAR', emoji: '🌠', label: 'Shooting Star' },
+  balloons:      { tag: 'BIRTHDAY',      emoji: '🎈', label: 'Balloons' },
+  birthday:      { tag: 'BIRTHDAY',      emoji: '🎈', label: 'Balloons' },
+  horror:        { tag: 'HORROR',        emoji: '👻', label: 'Horror' },
+  halloween:     { tag: 'HORROR',        emoji: '👻', label: 'Horror' },
+  las_vegas:     { tag: 'LAS_VEGAS',     emoji: '🎰', label: 'Las Vegas' },
+  vegas:         { tag: 'LAS_VEGAS',     emoji: '🎰', label: 'Las Vegas' },
+  anniversary:   { tag: 'ANNIVERSARY',   emoji: '💍', label: 'Anniversary' },
+  spotlight:     { tag: 'SPOTLIGHT',     emoji: '✨', label: 'Spotlight' },
+};
+
+function resolveEffect(name) {
+  if (!name) return null;
+  const key = String(name).toLowerCase().replace(/[\s\-]+/g, '_');
+  return EFFECTS[key] ? EFFECTS[key].tag : name.toUpperCase();
+}
+
+function buildForm(effectTag, msgObj, threadID, ctx) {
+  const messageAndOTID = utils.generateOfflineThreadingID();
+  const timestamp = Date.now();
+  const messagingTag = 'fb.messaging.effects.' + effectTag;
+  const body = typeof msgObj === 'string' ? msgObj : (msgObj.body || '');
+
+  const form = {
+    client:               'mercury',
+    action_type:          'ma-type:user-generated-message',
+    author:               'fbid:' + ctx.userID,
+    timestamp,
+    timestamp_absolute:   'Today',
+    timestamp_relative:   utils.generateTimestampRelative(),
+    timestamp_time_passed:'0',
+    is_unread:            false,
+    is_cleared:           false,
+    is_forward:           false,
+    is_filtered_content:  false,
+    is_filtered_content_bh: false,
+    is_filtered_content_account: false,
+    is_filtered_content_quasar: false,
+    is_filtered_content_invalid_app: false,
+    is_spoof_warning:     false,
+    source:               'source:chat:web',
+    'source_tags[0]':     'source:chat',
+    body,
+    html_body:            false,
+    ui_push_phase:        'V3',
+    status:               '0',
+    offline_threading_id: messageAndOTID,
+    message_id:           messageAndOTID,
+    threading_id:         utils.generateThreadingID(ctx.clientID),
+    'ephemeral_ttl_mode:':'0',
+    manual_retry_cnt:     '0',
+    has_attachment:       !!(msgObj && msgObj.sticker),
+    signatureID:          utils.getSignatureID(),
+    has_lightweight_action:                          true,
+    'lightweight_action_attached[message_id]':       messageAndOTID,
+    'lightweight_action_attached[messaging_tag]':    messagingTag,
+  };
+
+  if (msgObj && msgObj.sticker) {
+    form.sticker_id = msgObj.sticker;
+  }
+
+  if (typeof msgObj === 'object' && msgObj.reply_to_message_id) {
+    form.replied_to_message_id = msgObj.reply_to_message_id;
+  }
+
+  const tid = String(threadID);
+  const isGroup = tid.length >= 16;
+  if (isGroup) {
+    form.thread_fbid = tid;
+  } else {
+    form['specific_to_list[0]'] = 'fbid:' + tid;
+    form['specific_to_list[1]'] = 'fbid:' + ctx.userID;
+    form.other_user_fbid        = tid;
+    form.client_thread_id       = 'root:' + messageAndOTID;
+  }
+
+  return { form, messageAndOTID, timestamp, messagingTag };
+}
+
+function buildMqttPayload(effectTag, msgObj, threadID, ctx) {
+  const otid      = utils.generateOfflineThreadingID();
+  const epoch_id  = (BigInt(Date.now()) << 22n).toString();
+  const timestamp = Date.now();
+  const body      = typeof msgObj === 'string' ? msgObj : (msgObj && msgObj.body || '');
+  const tid       = String(threadID);
+
+  const sendPayload = {
+    thread_id:            tid,
+    otid:                 otid.toString(),
+    source:               2097153,
+    send_type:            1,
+    sync_group:           1,
+    text:                 body || null,
+    initiating_source:    0,
+    mark_thread_read:     1,
+    multitab_env:         0,
+    skip_url_preview_gen: 0,
+    metadata_dataclass:   JSON.stringify({ media_accessibility_metadata: { alt_text: null } }),
+    lightweight_action_attached: {
+      message_id:   otid.toString(),
+      messaging_tag: 'fb.messaging.effects.' + effectTag,
+    },
+  };
+
+  if (typeof msgObj === 'object' && msgObj && msgObj.sticker) {
+    sendPayload.send_type  = 2;
+    sendPayload.sticker_id = msgObj.sticker;
+    sendPayload.text       = null;
+  }
+
+  if (typeof ctx.wsReqNumber !== 'number') ctx.wsReqNumber = 0;
+  const request_id = ++ctx.wsReqNumber;
+
+  const content = {
+    app_id:  '2220391788200892',
+    payload: JSON.stringify({
+      tasks: [
+        {
+          label:         '46',
+          payload:       JSON.stringify(sendPayload),
+          queue_name:    tid,
+          task_id:       400,
+          failure_count: null,
+        },
+        {
+          label:  '21',
+          payload: JSON.stringify({
+            thread_id:              tid,
+            last_read_watermark_ts: timestamp,
+            sync_group:             1,
+          }),
+          queue_name:    tid,
+          task_id:       401,
+          failure_count: null,
+        },
+      ],
+      epoch_id,
+      version_id:    '24804310205905615',
+      data_trace_id: `#${Buffer.from(String(Math.random())).toString('base64').replace(/=+$/, '')}`,
+    }),
+    request_id,
+    type: 3,
+  };
+
+  return { content, request_id, otid, timestamp };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Lists all available send effects.
+   * @returns {Array<{tag, label, emoji, aliases}>}
+   */
+  function list() {
+    const seen  = new Set();
+    const result = [];
+    for (const [alias, { tag, label, emoji }] of Object.entries(EFFECTS)) {
+      if (!seen.has(tag)) {
+        seen.add(tag);
+        result.push({
+          tag,
+          label,
+          emoji,
+          aliases: Object.entries(EFFECTS).filter(([, v]) => v.tag === tag).map(([k]) => k),
+        });
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Sends a message with a visual effect animation.
+   *
+   * @param {string}          effectName  Effect alias or tag (e.g. 'fire', 'LOVE', 'confetti')
+   * @param {string|object}   message     Message text or object ({ body, sticker, reply_to_message_id })
+   * @param {string|number}   threadID    Thread / conversation ID
+   * @param {Function}        [callback]  Optional callback(err, { messageID, threadID, effect, timestamp })
+   * @returns {Promise}
+   */
+  async function send(effectName, message, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!callback) {
+      callback = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    try {
+      if (!effectName) return callback(new Error('effectName is required.'));
+      if (message === undefined || message === null) return callback(new Error('message is required.'));
+      if (!threadID) return callback(new Error('threadID is required.'));
+
+      const effectTag = resolveEffect(effectName);
+      utils.log('sendEffect', `Effect "${effectTag}" → thread ${threadID}`);
+
+      // ── MQTT-first (effects require MQTT; HTTP messaging/send strips them) ──
+      const mqttReady = ctx.mqttClient && ctx.mqttClient.connected;
+
+      if (mqttReady) {
+        const { content, request_id, otid, timestamp } = buildMqttPayload(effectTag, message, threadID, ctx);
+
+        await new Promise((res, rej) => {
+          let done    = false;
+          const timer = setTimeout(() => {
+            if (done) return;
+            done = true;
+            ctx.mqttClient.removeListener('message', onMsg);
+            rej(new Error('MQTT effect send timeout'));
+          }, 15000);
+
+          const onMsg = (topic, raw) => {
+            if (topic !== '/ls_resp') return;
+            let parsed;
+            try { parsed = JSON.parse(raw.toString()); parsed.payload = JSON.parse(parsed.payload); } catch { return; }
+            if (parsed.request_id !== request_id) return;
+            if (done) return;
+            done = true;
+            clearTimeout(timer);
+            ctx.mqttClient.removeListener('message', onMsg);
+            callback(null, { threadID, messageID: otid.toString(), timestamp, effect: effectTag, method: 'mqtt' });
+            res();
+          };
+
+          if (typeof ctx.mqttClient.setMaxListeners === 'function') ctx.mqttClient.setMaxListeners(0);
+          ctx.mqttClient.on('message', onMsg);
+          ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+            if (err && !done) {
+              done = true;
+              clearTimeout(timer);
+              ctx.mqttClient.removeListener('message', onMsg);
+              rej(err);
+            }
+          });
+        });
+        return returnPromise;
+      }
+
+      // ── HTTP fallback (last resort — effects may not render on all clients) ─
+      utils.warn('sendEffect', 'MQTT not connected, falling back to HTTP (effects may not animate).');
+      const { form, messageAndOTID, timestamp: httpTs } = buildForm(effectTag, message, threadID, ctx);
+
+      const resData = await defaultFuncs
+        .post('https://www.facebook.com/messaging/send/', ctx.jar, form, { ...ctx, requestThreadID: String(threadID) })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (!resData) throw new Error('Empty response from messaging/send');
+      if (resData.error) throw new Error(JSON.stringify(resData));
+
+      const actions = (resData.payload && resData.payload.actions) || [];
+      const msgInfo = actions.reduce((p, v) => ({
+        threadID:  v.thread_fbid  || p.threadID,
+        messageID: v.message_id   || p.messageID,
+        timestamp: v.timestamp    || p.timestamp,
+      }), { threadID, messageID: messageAndOTID, timestamp: httpTs });
+
+      return callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
+
+    } catch (err) {
+      utils.error('sendEffect', err.message || err);
+      callback(err instanceof Error ? err : new Error(String(err.message || err)));
+    }
+
+    return returnPromise;
+  }
+
+  // ── Convenience shortcuts ──────────────────────────────────────────────────
+  const shortcuts = {};
+  const seen = new Set();
+  for (const [alias, { tag }] of Object.entries(EFFECTS)) {
+    if (!seen.has(tag)) {
+      seen.add(tag);
+      const _tag = tag;
+      shortcuts[alias] = (message, threadID, callback) => send(_tag, message, threadID, callback);
+    }
+  }
+
+  return {
+    list,
+    send,
+    effects: EFFECTS,
+    resolveEffect,
+    ...shortcuts,
+  };
+};

package/src/apis/sendMessage.js

@@ -0,0 +1,341 @@
+"use strict";
+
+const utils = require('../utils');
+const { globalAntiSuspension } = require('../utils/antiSuspension');
+
+const allowedProperties = {
+  attachment: true,
+  url: true,
+  sticker: true,
+  emoji: true,
+  emojiSize: true,
+  body: true,
+  mentions: true,
+  location: true,
+  effect: true,
+  replyToMessage: true,
+};
+
+module.exports = (defaultFuncs, api, ctx) => {
+  async function getUrl(url) {
+    const resData = await defaultFuncs.post(
+      "https://www.facebook.com/message_share_attachment/fromURI/",
+      ctx.jar,
+      { image_height: 960, image_width: 960, uri: url }
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData || resData.error || !resData.payload) throw new Error("Invalid url");
+    return resData.payload.share_data.share_params;
+  }
+
+  function detectAttachmentType(attachment) {
+    const p = attachment.path || '';
+    const ext = p.toLowerCase().split('.').pop();
+    const audioTypes = ['mp3', 'wav', 'aac', 'm4a', 'ogg', 'opus', 'flac'];
+    const videoTypes = ['mp4', 'mov', 'avi', 'mkv', 'webm', 'wmv', 'flv'];
+    const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg'];
+    if (audioTypes.includes(ext)) return { voice_clip: "true" };
+    if (videoTypes.includes(ext)) return { video: "true" };
+    if (imageTypes.includes(ext)) return { image: "true" };
+    return { file: "true" };
+  }
+
+  async function uploadSingleAttachment(attachment, threadIDHint) {
+    if (!utils.isReadableStream(attachment)) {
+      throw new Error("Attachment should be a readable stream and not " + utils.getType(attachment) + ".");
+    }
+    const uploadType = detectAttachmentType(attachment);
+    const oksir = await defaultFuncs.postFormData(
+      "https://upload.facebook.com/ajax/mercury/upload.php",
+      ctx.jar,
+      { upload_1024: attachment, ...uploadType },
+      {},
+      { ...ctx, requestThreadID: threadIDHint }
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (oksir.error) throw new Error(JSON.stringify(oksir));
+    return oksir.payload.metadata[0];
+  }
+
+  async function uploadAttachment(attachments, threadIDHint) {
+    const CONCURRENT_UPLOADS = 2;
+    const uploads = [];
+    for (let i = 0; i < attachments.length; i += CONCURRENT_UPLOADS) {
+      const batch = attachments.slice(i, i + CONCURRENT_UPLOADS);
+      const results = await Promise.all(batch.map(a => uploadSingleAttachment(a, threadIDHint)));
+      uploads.push(...results);
+      if (i + CONCURRENT_UPLOADS < attachments.length) {
+        await globalAntiSuspension.addSmartDelay();
+      }
+    }
+    return uploads;
+  }
+
+  function getThreadCache() {
+    if (!ctx.threadTypeCache) ctx.threadTypeCache = Object.create(null);
+    return ctx.threadTypeCache;
+  }
+
+  async function isGroupThread(threadID, explicitIsGroup) {
+    if (utils.getType(explicitIsGroup) === "Boolean") return !!explicitIsGroup;
+    const tid = threadID.toString();
+    const cache = getThreadCache();
+    if (Object.prototype.hasOwnProperty.call(cache, tid)) return !!cache[tid];
+    try {
+      const info = await api.getThreadInfo(tid);
+      cache[tid] = !!info.isGroup;
+      return !!info.isGroup;
+    } catch (_) {
+      const fallback = tid.length >= 16;
+      cache[tid] = fallback;
+      return fallback;
+    }
+  }
+
+  async function sendViaHttp(msg, threadID, replyToMessage, isGroup) {
+    const isSingleUser = !(await isGroupThread(threadID, isGroup));
+    let messageAndOTID = utils.generateOfflineThreadingID();
+    let form = {
+      client: "mercury",
+      action_type: "ma-type:user-generated-message",
+      author: "fbid:" + ctx.userID,
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_filtered_content_bh: false,
+      is_filtered_content_account: false,
+      is_filtered_content_quasar: false,
+      is_filtered_content_invalid_app: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      ...(msg.body && { body: msg.body }),
+      html_body: false,
+      ui_push_phase: "V3",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      "ephemeral_ttl_mode:": "0",
+      manual_retry_cnt: "0",
+      has_attachment: !!(msg.attachment || msg.url || msg.sticker),
+      signatureID: utils.getSignatureID(),
+      ...(replyToMessage && { replied_to_message_id: replyToMessage })
+    };
+
+    if (msg.location) {
+      if (!msg.location.latitude || !msg.location.longitude) throw new Error("location property needs both latitude and longitude");
+      form["location_attachment[coordinates][latitude]"] = msg.location.latitude;
+      form["location_attachment[coordinates][longitude]"] = msg.location.longitude;
+      form["location_attachment[is_current_location]"] = !!msg.location.current;
+    }
+    if (msg.sticker) form["sticker_id"] = msg.sticker;
+    if (msg.effect) {
+      const effectTag = String(msg.effect).toUpperCase().replace(/[\s\-]+/g, '_');
+      form.has_lightweight_action = true;
+      form['lightweight_action_attached[message_id]'] = messageAndOTID;
+      form['lightweight_action_attached[messaging_tag]'] = 'fb.messaging.effects.' + effectTag;
+    }
+    if (msg.attachment) {
+      form.image_ids = [];
+      form.gif_ids = [];
+      form.file_ids = [];
+      form.video_ids = [];
+      form.audio_ids = [];
+      if (utils.getType(msg.attachment) !== "Array") msg.attachment = [msg.attachment];
+      const files = await uploadAttachment(msg.attachment, threadID);
+      files.forEach(file => {
+        const type = Object.keys(file)[0];
+        form["" + type + "s"].push(file[type]);
+      });
+    }
+    if (msg.url) {
+      form["shareable_attachment[share_type]"] = "100";
+      const params = await getUrl(msg.url);
+      form["shareable_attachment[share_params]"] = params;
+    }
+    if (msg.emoji) {
+      if (!msg.emojiSize) msg.emojiSize = "medium";
+      if (msg.emojiSize !== "small" && msg.emojiSize !== "medium" && msg.emojiSize !== "large") throw new Error("emojiSize property is invalid");
+      if (form.body && form.body !== "") throw new Error("body is not empty");
+      form.body = msg.emoji;
+      form["tags[0]"] = "hot_emoji_size:" + msg.emojiSize;
+    }
+    if (msg.mentions) {
+      for (let i = 0; i < msg.mentions.length; i++) {
+        const mention = msg.mentions[i];
+        const tag = mention.tag;
+        if (typeof tag !== "string") throw new Error("Mention tags must be strings.");
+        const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+        if (offset < 0) utils.warn("handleMention", 'Mention for "' + tag + '" not found in message string.');
+        const id = mention.id || 0;
+        const emptyChar = '\u200E';
+        form["body"] = emptyChar + msg.body;
+        form["profile_xmd[" + i + "][offset]"] = offset + 1;
+        form["profile_xmd[" + i + "][length]"] = tag.length;
+        form["profile_xmd[" + i + "][id]"] = id;
+        form["profile_xmd[" + i + "][type]"] = "p";
+      }
+    }
+
+    if (utils.getType(threadID) === "Array") {
+      for (let i = 0; i < threadID.length; i++) form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
+      form["specific_to_list[" + threadID.length + "]"] = "fbid:" + ctx.userID;
+      form["client_thread_id"] = "root:" + messageAndOTID;
+    } else {
+      if (isSingleUser) {
+        form["specific_to_list[0]"] = "fbid:" + threadID;
+        form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+        form["other_user_fbid"] = threadID;
+        form["client_thread_id"] = "root:" + messageAndOTID;
+      } else {
+        form["thread_fbid"] = threadID;
+      }
+    }
+    if (ctx.globalOptions.pageID) {
+      form["author"] = "fbid:" + ctx.globalOptions.pageID;
+      form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
+      form["creator_info[creatorID]"] = ctx.userID;
+      form["creator_info[creatorType]"] = "direct_admin";
+      form["creator_info[labelType]"] = "sent_message";
+      form["creator_info[pageID]"] = ctx.globalOptions.pageID;
+      form["request_user_id"] = ctx.globalOptions.pageID;
+      form["creator_info[profileURI]"] = "https://www.facebook.com/profile.php?id=" + ctx.userID;
+    }
+
+    const resData = await defaultFuncs.post(
+      "https://www.facebook.com/messaging/send/",
+      ctx.jar,
+      form,
+      { ...ctx, requestThreadID: threadID }
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (!resData) throw new Error("Send message failed.");
+    if (resData.error) {
+      if (resData.error === 1545012) utils.warn("sendMessage", "Got error 1545012. This might mean that you're not part of the conversation " + threadID);
+      globalAntiSuspension.detectSuspensionSignal(String(resData.error) + ' ' + JSON.stringify(resData));
+      throw new Error(JSON.stringify(resData));
+    }
+    const messageInfo = resData.payload.actions.reduce((p, v) => {
+      return { threadID: v.thread_fbid, messageID: v.message_id, timestamp: v.timestamp } || p;
+    }, null);
+    return messageInfo;
+  }
+
+  return async (msg, threadID, callback, replyToMessage, isGroup) => {
+    if (!callback && (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction")) {
+      throw new Error("Pass a threadID as a second argument.");
+    }
+    if (!replyToMessage && utils.getType(callback) === "String") {
+      replyToMessage = callback;
+      callback = undefined;
+    }
+
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    let returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    let msgType = utils.getType(msg);
+    let threadIDType = utils.getType(threadID);
+    let messageIDType = utils.getType(replyToMessage);
+
+    if (msgType !== "String" && msgType !== "Object") {
+      return callback(new Error("Message should be of type string or object and not " + msgType + "."));
+    }
+    if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String") {
+      return callback(new Error("ThreadID should be of type number, string, or array and not " + threadIDType + "."));
+    }
+    if (replyToMessage && messageIDType !== 'String') {
+      return callback(new Error("MessageID should be of type string and not " + threadIDType + "."));
+    }
+
+    if (ctx.validator && !ctx.validator.isValidMessage(msg)) {
+      return callback(new Error("Invalid message content"));
+    }
+    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
+    if (ctx.validator && !ctx.validator.validateIDArray(threadIDs, ctx.validator.isValidThreadID)) {
+      return callback(new Error("Invalid thread ID(s)"));
+    }
+
+    if (msgType === "String") msg = { body: msg };
+
+    let disallowedProperties = Object.keys(msg).filter(prop => !allowedProperties[prop]);
+    if (disallowedProperties.length > 0) {
+      return callback(new Error("Dissallowed props: `" + disallowedProperties.join(", ") + "`"));
+    }
+
+    try {
+      await globalAntiSuspension.prepareBeforeMessage(String(Array.isArray(threadID) ? threadID[0] : threadID), msg.body || '');
+
+      let typingStarted = false;
+      let typingTimeout;
+      const shouldSimulateTyping = ctx.globalOptions && ctx.globalOptions.simulateTyping && api.sendTypingIndicator && ctx.mqttClient && ctx.mqttClient.connected;
+      if (shouldSimulateTyping) {
+        try {
+          await api.sendTypingIndicator(true, threadID);
+          typingStarted = true;
+          const msgLen = (msg.body || '').length;
+          const typingMs = await globalAntiSuspension.simulateTyping(threadID, msgLen);
+          await new Promise(resolve => setTimeout(resolve, typingMs));
+          typingTimeout = setTimeout(() => {
+            if (typingStarted) {
+              try { api.sendTypingIndicator(false, threadID); } catch (_) {}
+              typingStarted = false;
+            }
+          }, 10000);
+        } catch (_) {}
+      }
+
+      try {
+        let result;
+        const mqttReady = ctx.mqttClient && ctx.mqttClient.connected;
+        const isMultiRecipient = Array.isArray(threadID);
+
+        if (mqttReady && !isMultiRecipient && api.sendMessageMqtt) {
+          result = await api.sendMessageMqtt(msg, threadID, replyToMessage);
+        } else {
+          result = await sendViaHttp(msg, threadID, replyToMessage, isGroup);
+        }
+        callback(null, result);
+      } catch (sendErr) {
+        const mqttReady = ctx.mqttClient && ctx.mqttClient.connected;
+        if (mqttReady && !Array.isArray(threadID) && api.sendMessageMqtt) {
+          try {
+            const mqttRes = await api.sendMessageMqtt(msg, threadID, replyToMessage);
+            callback(null, mqttRes);
+          } catch (_mqttErr) {
+            callback(sendErr);
+          }
+        } else {
+          try {
+            const httpRes = await sendViaHttp(msg, threadID, replyToMessage, isGroup);
+            callback(null, httpRes);
+          } catch (_httpErr) {
+            callback(sendErr);
+          }
+        }
+      } finally {
+        if (typingTimeout) clearTimeout(typingTimeout);
+        if (typingStarted) {
+          try { await api.sendTypingIndicator(false, threadID); } catch (_) {}
+        }
+      }
+    } catch (err) {
+      callback(err);
+    }
+    return returnPromise;
+  };
+};