@lazyneoaz/metachat 1.0.9 → 1.0.11

package/src/apis/listenMqtt.js

@@ -331,6 +331,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
     }));
 
     mqttClient.on('connect', guard("connect", async () => {
+        const wasReconnect = !ctx._mqttConnected && (ctx._reconnectAttempts || 0) > 0;
         if (!ctx._mqttConnected) {
             utils.log("MQTT connected successfully");
             ctx._mqttConnected = true;
@@ -338,6 +339,17 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
         ctx._cycling = false;
         ctx._reconnectAttempts = 0;
         ctx._mqttQuickCloseCount = 0;
+
+        // Update reconnect stats and emit lifecycle events
+        if (!ctx._reconnectStats) ctx._reconnectStats = { totalAttempts: 0, lastAttemptAt: null, nextAttemptAt: null, lastSuccessAt: null };
+        ctx._reconnectStats.nextAttemptAt = null;
+        ctx._reconnectStats.lastSuccessAt = Date.now();
+        try {
+            if (ctx._emitter) {
+                const eventName = wasReconnect ? 'reconnected' : 'connected';
+                ctx._emitter.emit(eventName, { timestamp: Date.now(), totalReconnects: ctx._reconnectStats.totalAttempts });
+            }
+        } catch (_) {}
         if (ctx._reconnectTimer) {
             clearTimeout(ctx._reconnectTimer);
             ctx._reconnectTimer = null;
@@ -440,7 +452,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     ctx.syncToken = jsonMessage.syncToken;
                 }
                 if (jsonMessage.lastIssuedSeqId) {
-                    ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+                    ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId, 10);
                 }
 
                 if (jsonMessage.deltas) {
@@ -583,7 +595,8 @@ const MQTT_DEFAULTS = {
     autoReconnect: true,
     watchdogIntervalMs: 60000,
     staleMs: 300000,
-    reconnectAfterStop: false 
+    reconnectAfterStop: false,
+    maxReconnectAttempts: 100
 };
 
 function mqttConf(ctx, overrides) {
@@ -812,11 +825,67 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             const msg = ((err && err.error) || (err && err.message) || String(err || "")) + detail;
             
             if (/Not logged in/i.test(msg)) {
-                utils.error("MQTT", "Auth error in getSeqID: Not logged in");
+                utils.error("MQTT", "Auth error in getSeqID: Not logged in — attempting recovery...");
+                
+                // Step 1: Try token refresh first (fastest, least invasive)
+                let tokenRefreshed = false;
+                try {
+                    if (api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
+                        utils.log("MQTT", "getSeqID: refreshing tokens before giving up...");
+                        await api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, 'https://www.facebook.com');
+                        tokenRefreshed = true;
+                        utils.log("MQTT", "getSeqID: token refresh succeeded, scheduling reconnect");
+                    }
+                } catch (refreshErr) {
+                    utils.warn("MQTT", `getSeqID: token refresh failed: ${refreshErr && refreshErr.message ? refreshErr.message : refreshErr}`);
+                }
+                
+                if (tokenRefreshed && ctx.globalOptions.autoReconnect) {
+                    ctx._reconnectAttempts = Math.max(0, (ctx._reconnectAttempts || 0) - 1);
+                    const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 3000;
+                    return scheduleReconnect(baseDelay);
+                }
+                
+                // Step 2: Try full auto re-login (email+password) as last resort
+                let reloginOk = false;
+                try {
+                    const { globalAutoReLoginManager } = require('../utils/autoReLogin');
+                    if (globalAutoReLoginManager && globalAutoReLoginManager.isEnabled && globalAutoReLoginManager.isEnabled()) {
+                        utils.log("MQTT", "getSeqID: attempting auto re-login...");
+                        reloginOk = await globalAutoReLoginManager.handleSessionExpiry(api, 'https://www.facebook.com', "MQTT getSeqID Not logged in");
+                        if (reloginOk) {
+                            utils.log("MQTT", "getSeqID: re-login succeeded, scheduling MQTT reconnect");
+                        }
+                    }
+                } catch (reloginErr) {
+                    utils.warn("MQTT", `getSeqID: auto re-login failed: ${reloginErr && reloginErr.message ? reloginErr.message : reloginErr}`);
+                }
+                
+                if (reloginOk && ctx.globalOptions.autoReconnect) {
+                    ctx._reconnectAttempts = 0;
+                    const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 5000;
+                    return scheduleReconnect(baseDelay);
+                }
+                
+                // Both recovery paths exhausted — emit auth error to signal the user
                 return emitAuthError("not_logged_in", msg);
             }
             if (/blocked the login|checkpoint|security check|session.*expir|invalid.*session|authentication.*fail|auth.*fail|login.*block|account.*lock|verification.*requir/i.test(msg)) {
                 utils.error("MQTT", "Auth error in getSeqID: Session/Login blocked");
+                
+                // Still try token refresh for session expiry before giving up
+                try {
+                    if (api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
+                        utils.log("MQTT", "getSeqID: refreshing tokens on session expiry...");
+                        await api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, 'https://www.facebook.com');
+                        if (ctx.globalOptions.autoReconnect) {
+                            ctx._reconnectAttempts = 0;
+                            const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 5000;
+                            return scheduleReconnect(baseDelay);
+                        }
+                    }
+                } catch (_) {}
+                
                 return emitAuthError("login_blocked", msg);
             }
             

package/src/apis/markAsSeen.js

@@ -10,8 +10,8 @@ const utils = require('../utils');
 module.exports = function (defaultFuncs, api, ctx) {
   /**
    * Marks all messages as "seen" up to a specific timestamp.
-   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
-   * @param {Function} [callback] - The callback function.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in ms) up to which messages should be marked as seen.
+   * @param {Function} [callback] - Optional callback function.
    * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
    */
   return async function markAsSeen(seen_timestamp, callback) {
@@ -30,11 +30,9 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     if (!callback) {
-      callback = function (err, friendList) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(friendList);
+      callback = function (err) {
+        if (err) return rejectFunc(err);
+        resolveFunc();
       };
     }
 
@@ -56,13 +54,13 @@ module.exports = function (defaultFuncs, api, ctx) {
         throw resData;
       }
 
-      return callback();
+      callback(null);
     } catch (err) {
       utils.error("markAsSeen", err);
       if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
         ctx.loggedIn = false;
       }
-      return callback(err);
+      callback(err);
     }
 
     return returnPromise;

package/src/apis/nickname.js

@@ -1,19 +1,21 @@
 "use strict";
 
 const utils = require('../utils');
+const { publishLsRequestWithAck, buildLsTask, generateEpochId } = require('../utils/lsRequest');
+
+const NICKNAME_VERSION_ID = "25459622483894963";
 
 module.exports = function (defaultFuncs, api, ctx) { 
   /**
-   * Made by Choru Official 
-   * Mqtt
-   * Sets a nickname for a participant in a Facebook thread via MQTT.
+   * Sets a nickname for a participant in a Facebook thread via MQTT with ACK.
+   * Uses publishLsRequestWithAck for reliable delivery confirmation.
    *
-   * @param {string} nickname The new nickname to set.
+   * @param {string} nickname The new nickname to set (empty string to clear).
    * @param {string} threadID The ID of the thread.
-   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
-   * @param {Function} [callback] Optional callback function to be invoked upon completion.
-   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
-   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   * @param {string} participantID The ID of the participant. Defaults to the bot's ID.
+   * @param {Function} [callback] Optional callback(err, result).
+   * @param {string} [initiatorID] The senderID who triggered the change (for event tracking).
+   * @returns {Promise<object>}
    */
   return function setNickname(nickname, threadID, participantID, callback, initiatorID) {
     let _callback;
@@ -37,8 +39,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         _callback = participantID;
         participantID = ctx.userID;
         _initiatorID = callback;
-    }
-    else if (utils.getType(callback) === "string") {
+    } else if (utils.getType(callback) === "string") {
         _initiatorID = callback;
         _callback = undefined;
     } else {
@@ -65,66 +66,82 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     _initiatorID = _initiatorID || ctx.userID;
-
     threadID = threadID || ctx.threadID;
     participantID = participantID || ctx.userID;
 
     if (!threadID) {
-      return _callback(new Error("threadID is required to set a nickname."));
+      _callback(new Error("threadID is required to set a nickname."));
+      return returnPromise;
     }
     if (typeof nickname !== 'string') {
-      return _callback(new Error("nickname must be a string."));
+      _callback(new Error("nickname must be a string."));
+      return returnPromise;
     }
-
-    if (!ctx.mqttClient) {
-      return _callback(new Error("Not connected to MQTT"));
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      _callback(new Error("Not connected to MQTT — call listenMqtt() first before using setNickname."));
+      return returnPromise;
     }
 
-    ctx.wsReqNumber += 1;
-    ctx.wsTaskNumber += 1;
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    if (typeof ctx.wsTaskNumber !== "number") ctx.wsTaskNumber = 0;
 
-    const queryPayload = {
+    const requestId = ++ctx.wsReqNumber;
+    const task = buildLsTask(ctx, "44", "thread_participant_nickname", {
       thread_key: threadID.toString(),
       contact_id: participantID.toString(),
       nickname: nickname,
-      sync_group: 1,
-    };
+      sync_group: 1
+    });
 
-    const query = {
-      failure_count: null,
-      label: '44',
-      payload: JSON.stringify(queryPayload),
-      queue_name: 'thread_participant_nickname',
-      task_id: ctx.wsTaskNumber,
+    const envelope = {
+      app_id: String(ctx.appID || ctx.mqttAppID || "2220391788200892"),
+      payload: JSON.stringify({
+        epoch_id: generateEpochId(),
+        tasks: [task],
+        version_id: NICKNAME_VERSION_ID
+      }),
+      request_id: requestId,
+      type: 3
     };
 
-    const context = {
-      app_id: ctx.appID || "2220391788200892",
-      payload: {
-        epoch_id: parseInt(utils.generateOfflineThreadingID()),
-        tasks: [query],
-        version_id: '24631415369801570',
-      },
-      request_id: ctx.wsReqNumber,
-      type: 3,
-    };
-    context.payload = JSON.stringify(context.payload);
-    
-    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
-      if (err) {
-        return _callback(new Error(`MQTT publish failed for setNickname: ${err.message || err}`));
-      }
-      
-      const nicknameChangeEvent = {
-        type: "thread_nickname_update", 
-        threadID: threadID,
-        participantID: participantID,
+    publishLsRequestWithAck({
+      client: ctx.mqttClient,
+      content: envelope,
+      requestId,
+      timeoutMs: 12000,
+      extract: (message) => ({
+        type: "thread_nickname_update",
+        threadID,
+        participantID,
         newNickname: nickname,
         senderID: _initiatorID,
         BotID: ctx.userID,
         timestamp: Date.now(),
-      };
-      _callback(null, nicknameChangeEvent);
+        success: true,
+        ack: message.payload
+      })
+    }).then((result) => {
+      _callback(null, result);
+    }).catch((err) => {
+      // ACK timeout is non-fatal — the nickname was likely applied anyway.
+      // Build a best-effort result so callers still get a useful object.
+      if (err && err.message && err.message.includes("Timeout waiting for LS ACK")) {
+        utils.warn("setNickname", "ACK timed out — nickname may still have been applied");
+        _callback(null, {
+          type: "thread_nickname_update",
+          threadID,
+          participantID,
+          newNickname: nickname,
+          senderID: _initiatorID,
+          BotID: ctx.userID,
+          timestamp: Date.now(),
+          success: true,
+          ackTimeout: true
+        });
+      } else {
+        utils.error("setNickname", err && err.message ? err.message : err);
+        _callback(err instanceof Error ? err : new Error(String(err && err.message ? err.message : err)));
+      }
     });
 
     return returnPromise;

package/src/apis/pinMessage.js

@@ -83,7 +83,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       }
     }
 
-    if (!ctx.mqttClient) throw new Error("MQTT not connected.");
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) throw new Error("MQTT not connected.");
     if (!threadID || !messageID) throw new Error(`"${action}" requires threadID and messageID.`);
 
     const epoch_id = parseInt(utils.generateOfflineThreadingID());

package/src/apis/removeUserFromGroup.js

@@ -16,6 +16,13 @@ module.exports = (defaultFuncs, api, ctx) => {
         if (err) return rejectFunc(err);
         resolveFunc(result);
       };
+    } else {
+      const _userCb = callback;
+      callback = (err, result) => {
+        if (err) { _userCb(err); return rejectFunc(err); }
+        _userCb(null, result);
+        resolveFunc(result);
+      };
     }
 
     try {

package/src/apis/sendEffect.js

@@ -135,6 +135,7 @@ function buildMqttPayload(effectTag, msgObj, threadID, ctx) {
   }
 
   if (typeof ctx.wsReqNumber !== 'number') ctx.wsReqNumber = 0;
+  if (typeof ctx.wsTaskNumber !== 'number') ctx.wsTaskNumber = 0;
   const request_id = ++ctx.wsReqNumber;
 
   const content = {
@@ -145,7 +146,7 @@ function buildMqttPayload(effectTag, msgObj, threadID, ctx) {
           label:         '46',
           payload:       JSON.stringify(sendPayload),
           queue_name:    tid,
-          task_id:       400,
+          task_id:       ++ctx.wsTaskNumber,
           failure_count: null,
         },
         {
@@ -156,7 +157,7 @@ function buildMqttPayload(effectTag, msgObj, threadID, ctx) {
             sync_group:             1,
           }),
           queue_name:    tid,
-          task_id:       401,
+          task_id:       ++ctx.wsTaskNumber,
           failure_count: null,
         },
       ],
@@ -213,9 +214,9 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     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.'));
+      if (!effectName) { callback(new Error('effectName is required.')); return returnPromise; }
+      if (message === undefined || message === null) { callback(new Error('message is required.')); return returnPromise; }
+      if (!threadID) { callback(new Error('threadID is required.')); return returnPromise; }
 
       const effectTag = resolveEffect(effectName);
       utils.log('sendEffect', `Effect "${effectTag}" → thread ${threadID}`);
@@ -280,7 +281,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         timestamp: v.timestamp    || p.timestamp,
       }), { threadID, messageID: messageAndOTID, timestamp: httpTs });
 
-      return callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
+      callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
 
     } catch (err) {
       utils.error('sendEffect', err.message || err);

package/src/apis/sendMessage.js

@@ -220,7 +220,11 @@ module.exports = (defaultFuncs, api, ctx) => {
       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;
+      return {
+        threadID:  v.thread_fbid  || (p && p.threadID),
+        messageID: v.message_id   || (p && p.messageID),
+        timestamp: v.timestamp    || (p && p.timestamp),
+      };
     }, null);
     return messageInfo;
   }
@@ -259,7 +263,7 @@ module.exports = (defaultFuncs, api, ctx) => {
       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 + "."));
+      return callback(new Error("MessageID should be of type string and not " + messageIDType + "."));
     }
 
     if (ctx.validator && !ctx.validator.isValidMessage(msg)) {

package/src/apis/setMessageReaction.js

@@ -2,27 +2,66 @@
 
 const utils = require('../utils');
 
-
 module.exports = function (defaultFuncs, api, ctx) {
-  return async (reaction, messageID) => {
-    if (reaction === undefined || reaction === null) throw new Error("Please enter a valid emoji.");
-    const action = reaction === "" ? "REMOVE_REACTION" : "ADD_REACTION";
-    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {
-      doc_id: "1491398900900362",
-      variables: JSON.stringify({
-        data: {
-          client_mutation_id: ctx.clientMutationId++,
-          actor_id: ctx.userID,
-          action,
-          message_id: messageID,
-          reaction
-        }
-      }),
-      dpr: 1
-    }, {});
-    const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
-    if (!resData) {
-      throw new Error("setMessageReactionLegacy returned empty object.");
+  return async function setMessageReaction(reaction, messageID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    } else {
+      const _userCb = callback;
+      callback = (err, data) => {
+        if (err) { _userCb(err); return rejectFunc(err); }
+        _userCb(null, data);
+        resolveFunc(data);
+      };
     }
+
+    try {
+      if (reaction === undefined || reaction === null) {
+        throw new Error("Please enter a valid emoji.");
+      }
+
+      const action = reaction === "" ? "REMOVE_REACTION" : "ADD_REACTION";
+
+      const defData = await defaultFuncs.postFormData(
+        "https://www.facebook.com/webgraphql/mutation/",
+        ctx.jar,
+        {
+          doc_id: "3360163564070970",
+          variables: JSON.stringify({
+            data: {
+              client_mutation_id: ctx.clientMutationId++,
+              actor_id: ctx.userID,
+              action,
+              message_id: messageID,
+              reaction
+            }
+          }),
+          dpr: 1
+        },
+        {}
+      );
+
+      const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+      if (!resData) {
+        throw new Error("setMessageReaction returned empty object.");
+      }
+
+      callback(null, { success: true, action, messageID });
+    } catch (err) {
+      utils.error("setMessageReaction", err);
+      callback(err instanceof Error ? err : new Error(String(err)));
+    }
+
+    return returnPromise;
   };
 };

package/src/apis/setMessageReactionMqtt.js

@@ -1,61 +1,101 @@
+"use strict";
 
-'use strict';
-
+const { publishLsRequestWithAck } = require('../utils/lsRequest');
 const utils = require('../utils');
 
-function isCallable(func) {
-  try {
-    Reflect.apply(func, null, []);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
 module.exports = function (defaultFuncs, api, ctx) {
-  return function setMessageReactionMqtt(reaction, messageID, threadID) {
-    if (!ctx.mqttClient) {
-      throw new Error('Not connected to MQTT');
-    }
-
-    ctx.wsReqNumber += 1;
-    ctx.wsTaskNumber += 1;
-
-    const taskPayload = {
-      thread_key: threadID,
-      timestamp_ms: Date.now(),
-      message_id: messageID,
-      reaction,
-      actor_id: ctx.userID,
-      reaction_style: null,
-      sync_group: 1,
-      send_attribution: Math.random() < 0.5 ? 65537 : 524289
-    };
-
-    const task = {
-      failure_count: null,
-      label: '29',
-      payload: JSON.stringify(taskPayload),
-      queue_name: JSON.stringify(['reaction', messageID]),
-      task_id: ctx.wsTaskNumber
-    };
-
-    const content = {
-      app_id: '2220391788200892',
-      payload: JSON.stringify({
-        data_trace_id: null,
-        epoch_id: parseInt(utils.generateOfflineThreadingID()),
-        tasks: [task],
-        version_id: '7158486590867448',
-      }),
-      request_id: ctx.wsReqNumber,
-      type: 3,
-    };
-
-    /*if (isCallable(callback)) {
-      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
-    }*/
-
-    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
-  };
+  /**
+   * Sets or clears a reaction on a Messenger message via MQTT with ACK.
+   *
+   * @param {string}   reaction   Emoji string (e.g. "😍") or empty string to clear.
+   * @param {string}   messageID  The message ID.
+   * @param {string}   threadID   The thread ID.
+   * @param {Function} [callback] Optional callback(err, result).
+   * @returns {Promise}
+   */
+  return function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const cb = (typeof callback === "function")
+      ? (err, data) => { callback(err, data); if (err) rejectFunc(err); else resolveFunc(data); }
+      : (err, data) => { if (err) rejectFunc(err); else resolveFunc(data); };
+
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      const err = new Error("Not connected to MQTT — call listenMqtt() first");
+      return cb(err), returnPromise;
+    }
+
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    if (typeof ctx.wsTaskNumber !== "number") ctx.wsTaskNumber = 0;
+
+    const requestId = ++ctx.wsReqNumber;
+    const taskId = ++ctx.wsTaskNumber;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: Date.now(),
+      message_id: messageID,
+      reaction: reaction || "",
+      actor_id: ctx.userID,
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289
+    };
+
+    const task = {
+      failure_count: null,
+      label: "29",
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(["reaction", messageID]),
+      task_id: taskId
+    };
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: "7158486590867448"
+      }),
+      request_id: requestId,
+      type: 3
+    };
+
+    publishLsRequestWithAck({
+      client: ctx.mqttClient,
+      content,
+      requestId,
+      timeoutMs: 10000,
+      extract: (message) => ({
+        success: true,
+        messageID,
+        threadID,
+        reaction: reaction || "",
+        ack: message.payload
+      })
+    }).then((result) => {
+      cb(null, result);
+    }).catch((err) => {
+      if (err && err.message && err.message.includes("Timeout waiting for LS ACK")) {
+        utils.warn("setMessageReactionMqtt", "ACK timed out — reaction may still have been applied");
+        cb(null, {
+          success: true,
+          messageID,
+          threadID,
+          reaction: reaction || "",
+          ackTimeout: true
+        });
+      } else {
+        utils.error("setMessageReactionMqtt", err && err.message ? err.message : err);
+        cb(err instanceof Error ? err : new Error(String(err && err.message ? err.message : err)));
+      }
+    });
+
+    return returnPromise;
+  };
 };