@nexustechpro/baileys 2.1.3 → 2.1.6

package/lib/Signal/lid-mapping.js

@@ -28,9 +28,10 @@ export class LIDMappingStore {
 
         if (!validatedPairs.length) return
 
-        // Batch check all cache misses in one DB call
+        // Batch check all cache misses in one DB call (forward AND reverse)
         const cacheMissSet = new Set()
         const existingMappings = new Map()
+        const existingReverse = new Map()
 
         for (const { pnUser } of validatedPairs) {
             const cached = this.mappingCache.get(`pn:${pnUser}`)
@@ -51,15 +52,33 @@ export class LIDMappingStore {
             }
         }
 
+        // Separately verify the reverse entry actually exists on disk for every
+        // pair whose forward mapping we found — a forward file existing does NOT
+        // guarantee its `_reverse` sibling was ever written (e.g. when only the
+        // recipient side of a fromMe message was resolved, never the sender side).
+        const reverseKeysToCheck = []
+        for (const { pnUser, lidUser } of validatedPairs) {
+            if (existingMappings.get(pnUser) === lidUser) reverseKeysToCheck.push(`${lidUser}_reverse`)
+        }
+        if (reverseKeysToCheck.length) {
+            const storedReverse = await this.keys.get('lid-mapping', reverseKeysToCheck)
+            for (const key of reverseKeysToCheck) {
+                if (storedReverse[key]) existingReverse.set(key, storedReverse[key])
+            }
+        }
+
         const pairMap = {}
         for (const { pnUser, lidUser } of validatedPairs) {
-            if (existingMappings.get(pnUser) === lidUser) {
-                this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
+            const forwardExists = existingMappings.get(pnUser) === lidUser
+            const reverseExists = existingReverse.has(`${lidUser}_reverse`)
+            if (forwardExists && reverseExists) {
                 continue
             }
+            if (forwardExists && !reverseExists) {
+                this.logger.debug({ pnUser, lidUser }, 'forward mapping exists but reverse is missing, repairing')
+            }
             pairMap[pnUser] = lidUser
         }
-
         if (!Object.keys(pairMap).length) return
 
         this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)

package/lib/Socket/chats.js

@@ -772,6 +772,7 @@ export const makeChatsSocket = (config) => {
         addOrEditContact,
         removeContact,
         placeholderResendCache,
+        receiptMutex,
         addLabel,
         onWhatsApp,
         addChatLabel,

package/lib/Socket/messages-recv.js

@@ -13,16 +13,14 @@ import { makeMessagesSocket } from "./messages-send.js"
 export const makeMessagesRecvSocket = (config) => {
   const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config
   const sock = makeMessagesSocket(config)
-  const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, messageRetryManager, registerSocketEndHandler, issuePrivacyTokens, fetchAccountReachoutTimelock } = sock
+  const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, messageRetryManager, registerSocketEndHandler, issuePrivacyTokens, fetchAccountReachoutTimelock, placeholderResendCache: sockPlaceholderResendCache } = sock
 
   const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
-  const messageMutex = makeMutex()
-  const notificationMutex = makeMutex()
+  const { messageMutex, notificationMutex, receiptMutex: _receiptMutex, placeholderResendCache } = sock
   const retryMutex = makeMutex()
 
   const msgRetryCache = config.msgRetryCounterCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, useClones: false })
   const callOfferCache = config.callOfferCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER, useClones: false })
-  const placeholderResendCache = config.placeholderResendCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, useClones: false })
   const identityAssertDebounce = new NodeCache({ stdTTL: 5, useClones: false })
 
   let sendActiveReceipts = false
@@ -730,27 +728,28 @@ export const makeMessagesRecvSocket = (config) => {
       if (altServer === "lid") { if (!(await signalRepository.lidMapping.getPNForLID(alt))) { await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]); await signalRepository.migrateSession(primaryJid, alt) } }
       else { await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]); await signalRepository.migrateSession(alt, primaryJid) }
     }
-    if (msg.key?.remoteJid && msg.key?.id && messageRetryManager) { messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message); logger.debug({ jid: msg.key.remoteJid, id: msg.key.id }, "Added message to recent cache for retry receipts") }
+    let acked = false
     try {
       await messageMutex.mutex(async () => {
         await decrypt()
+        if (msg.key?.remoteJid && msg.key?.id && msg.message && messageRetryManager) { messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message) }
         if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT && msg.category !== "peer") {
-          if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) return sendMessageAck(node, NACK_REASONS.ParsingError)
+          if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) { acked = true; return sendMessageAck(node, NACK_REASONS.ParsingError) }
           if (msg.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
             const unavailableNode = getBinaryNodeChild(node, "unavailable")
             const unavailableType = unavailableNode?.attrs?.type
-            if (unavailableType === "bot_unavailable_fanout" || unavailableType === "hosted_unavailable_fanout" || unavailableType === "view_once_unavailable_fanout") { logger.debug({ msgId: msg.key.id, unavailableType }, "skipping placeholder resend for excluded unavailable type"); return sendMessageAck(node) }
+            if (unavailableType === "bot_unavailable_fanout" || unavailableType === "hosted_unavailable_fanout" || unavailableType === "view_once_unavailable_fanout") { logger.debug({ msgId: msg.key.id, unavailableType }, "skipping placeholder resend for excluded unavailable type"); acked = true; return sendMessageAck(node) }
             const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp)
-            if (messageAge > PLACEHOLDER_MAX_AGE_SECONDS) { logger.debug({ msgId: msg.key.id, messageAge }, "skipping placeholder resend for old message"); return sendMessageAck(node) }
+            if (messageAge > PLACEHOLDER_MAX_AGE_SECONDS) { logger.debug({ msgId: msg.key.id, messageAge }, "skipping placeholder resend for old message"); acked = true; return sendMessageAck(node) }
             const cleanKey = { remoteJid: msg.key.remoteJid, fromMe: msg.key.fromMe, id: msg.key.id, participant: msg.key.participant }
             const msgData = { key: msg.key, messageTimestamp: msg.messageTimestamp, pushName: msg.pushName, participant: msg.participant, verifiedBizName: msg.verifiedBizName }
             requestPlaceholderResend(cleanKey, msgData).then(requestId => { if (requestId && requestId !== "RESOLVED") { logger.debug({ msgId: msg.key.id, requestId }, "requested placeholder resend for unavailable message"); ev.emit("messages.update", [{ key: msg.key, update: { messageStubParameters: [NO_MESSAGE_FOUND_ERROR_TEXT, requestId] } }]) } }).catch(err => { logger.warn({ err, msgId: msg.key.id }, "failed to request placeholder resend for unavailable message") })
-            await sendMessageAck(node)
+            acked = true; await sendMessageAck(node)
           } else {
-            if ((msg.messageStubParameters?.[0] || '').includes('InvalidPreKeyId')) { logger.debug({ msgId: msg.key.id, remoteJid: msg.key.remoteJid }, 'skipping retry for InvalidPreKeyId, sender must re-establish session'); return sendMessageAck(node, NACK_REASONS.UnhandledError) }
+            if ((msg.messageStubParameters?.[0] || '').includes('InvalidPreKeyId')) { logger.debug({ msgId: msg.key.id, remoteJid: msg.key.remoteJid }, 'skipping retry for InvalidPreKeyId, sender must re-establish session'); acked = true; return sendMessageAck(node, NACK_REASONS.UnhandledError) }
             if (isJidStatusBroadcast(msg.key.remoteJid)) {
               const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp)
-              if (messageAge > STATUS_EXPIRY_SECONDS) { logger.debug({ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid }, "skipping retry for expired status message"); return sendMessageAck(node) }
+              if (messageAge > STATUS_EXPIRY_SECONDS) { logger.debug({ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid }, "skipping retry for expired status message"); acked = true; return sendMessageAck(node) }
             }
             retryMutex.mutex(async () => {
               try {
@@ -765,7 +764,7 @@ export const makeMessagesRecvSocket = (config) => {
                   await sendRetryRequest(node, !encNode)
                 } catch (retryErr) { logger.error({ retryErr }, "Final retry attempt failed") }
               }
-              await sendMessageAck(node, NACK_REASONS.UnhandledError)
+              acked = true; await sendMessageAck(node, NACK_REASONS.UnhandledError)
             })
           }
         } else {
@@ -777,14 +776,14 @@ export const makeMessagesRecvSocket = (config) => {
             if (category === "peer") type = "peer_msg"
             else if (msg.key.fromMe) { type = "sender"; if (isLidUser(msg.key.remoteJid) || isLidUser(msg.key.remoteJidAlt)) participant = author }
             else if (!sendActiveReceipts) type = "inactive"
-            await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type)
+            acked = true; await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type)
             const isAnyHistoryMsg = getHistoryMsg(msg.message)
             if (isAnyHistoryMsg) {
               const jid = jidNormalizedUser(msg.key.remoteJid)
               await sendReceipt(jid, undefined, [msg.key.id], "hist_sync")
             }
           } else {
-            await sendMessageAck(node)
+            acked = true; await sendMessageAck(node)
             logger.debug({ key: msg.key }, "processed newsletter message without receipts")
           }
         }
@@ -798,6 +797,9 @@ export const makeMessagesRecvSocket = (config) => {
       } else {
         logger.error({ error, stack: error?.stack, msg: error?.message || String(error), node: binaryNodeToString(node) }, "error in handling message")
       }
+      if (!acked) {
+        await sendMessageAck(node, NACK_REASONS.UnhandledError).catch(ackErr => logger.error({ ackErr }, "failed to ack message after error"))
+      }
     }
   }
 
@@ -877,7 +879,7 @@ export const makeMessagesRecvSocket = (config) => {
           const { type, node } = nodes.shift()
           const nodeProcessor = nodeProcessorMap.get(type)
           if (!nodeProcessor) { onUnexpectedError(new Error(`unknown offline node type: ${type}`), "processing offline node"); continue }
-          await nodeProcessor(node)
+          await nodeProcessor(node).catch(err => onUnexpectedError(err, `processing offline ${type}`))
           processedInBatch++
           if (processedInBatch >= BATCH_SIZE) { processedInBatch = 0; await yieldToEventLoop() }
         }
@@ -891,6 +893,11 @@ export const makeMessagesRecvSocket = (config) => {
   const offlineNodeProcessor = makeOfflineNodeProcessor()
 
   const processNode = async (type, node, identifier, exec) => {
+    const from = node.attrs.from
+    if (from && from !== S_WHATSAPP_NET && shouldIgnoreJid(from)) {
+      await sendMessageAck(node, type === 'message' ? NACK_REASONS.UnhandledError : undefined)
+      return
+    }
     const isOffline = !!node.attrs.offline
     if (isOffline) offlineNodeProcessor.enqueue(type, node)
     else await processNodeWithBuffer(node, identifier, exec)
@@ -942,8 +949,12 @@ export const makeMessagesRecvSocket = (config) => {
         else survivors.add(jid)
       }
       if (mutated === 0) return
-      const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [...survivors])
-      await authState.keys.set({ tctoken: { ...writes, ...indexWrite } })
+      await authState.keys.set({
+        tctoken: {
+          ...writes,
+          [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...survivors])) }
+        }
+      })
       tcTokenKnownJids.clear()
       for (const jid of survivors) tcTokenKnownJids.add(jid)
       logger.debug({ mutated, remaining: survivors.size }, 'pruned expired tctokens')

package/lib/Socket/messages-send.js

@@ -4,7 +4,7 @@ import * as Utils from '../Utils/index.js'
 import { proto } from '../../WAProto/index.js'
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js'
 import * as WABinary from '../WABinary/index.js'
-import { getUrlInfo, migrateIndexKey, getMessageReportingToken, shouldIncludeReportingToken, buildMergedTcTokenIndexWrite, isTcTokenExpired, readTcTokenIndex, resolveTcTokenJid, resolveIssuanceJid, shouldSendNewTcToken, storeTcTokensFromIqResult, makeKeyedMutex, makeMutex } from '../Utils/index.js'
+import { getUrlInfo, getMessageReportingToken, shouldIncludeReportingToken, buildMergedTcTokenIndexWrite, isTcTokenExpired, preSeedTcToken, resolveTcTokenJid, resolveIssuanceJid, shouldSendNewTcToken, storeTcTokensFromIqResult, makeKeyedMutex, makeMutex } from '../Utils/index.js'
 import { USyncQuery, USyncUser } from '../WAUSync/index.js'
 import { makeNewsletterSocket } from './newsletter.js'
 import NexusHandler from './nexus-handler.js'
@@ -31,7 +31,8 @@ export const makeMessagesSocket = (config) => {
     const sock = makeNewsletterSocket(config)
     const {
         ev, authState, processingMutex, signalRepository, upsertMessage, query,
-        fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral
+        fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral,
+        placeholderResendCache
     } = sock
 
     const userDevicesCache = config.userDevicesCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, useClones: false })
@@ -161,7 +162,7 @@ export const makeMessagesSocket = (config) => {
                 await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })))
                 try {
                     const lids = lidResults.map(a => a.lid)
-                    if (lids.length) await assertSessions(lids, false)
+                    if (lids.length) await assertSessions(lids, true)
                 } catch (e) {
                     logger.warn({ error: e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs')
                 }
@@ -190,17 +191,15 @@ export const makeMessagesSocket = (config) => {
                 }
             })
 
-            // Persist device lists for session migration (capped at 500 users)
+            // Persist device lists for session migration — one key per userId
             const userDeviceUpdates = {}
             for (const [userId, devices] of Object.entries(deviceMap)) {
                 if (devices?.length > 0) userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0')
             }
             if (Object.keys(userDeviceUpdates).length > 0) {
                 try {
-                    const currentBatch = await migrateIndexKey(authState.keys, 'device-list')
-                    const mergedBatch = { ...currentBatch, ...userDeviceUpdates }
-                    await authState.keys.set({ 'device-list': { 'index': mergedBatch } })
-                    logger.debug({ userCount: Object.keys(userDeviceUpdates).length, batchSize: Object.keys(mergedBatch).length }, 'stored user device lists')
+                    await authState.keys.set({ 'device-list': userDeviceUpdates })
+                    logger.debug({ userCount: Object.keys(userDeviceUpdates).length }, 'stored user device lists')
                 } catch (error) {
                     logger.warn({ error }, 'failed to store user device lists')
                 }
@@ -215,10 +214,10 @@ export const makeMessagesSocket = (config) => {
         if (force) {
             jidsRequiringFetch = jids
         } else {
-            const sessionBatch = await migrateIndexKey(authState.keys, 'session')
-            for (const jid of jids) {
-                const signalId = signalRepository.jidToSignalProtocolAddress(jid)
-                if (!sessionBatch[signalId]) jidsRequiringFetch.push(jid)
+            const signalIds = jids.map(jid => signalRepository.jidToSignalProtocolAddress(jid))
+            const sessionBatch = await authState.keys.get('session', signalIds)
+            for (let i = 0; i < jids.length; i++) {
+                if (!sessionBatch[signalIds[i]]) jidsRequiringFetch.push(jids[i])
             }
         }
         if (jidsRequiringFetch.length) {
@@ -226,9 +225,8 @@ export const makeMessagesSocket = (config) => {
                 ...jidsRequiringFetch.filter(jid => isLidUser(jid) || isHostedLidUser(jid)),
                 ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => isPnUser(jid) || isHostedPnUser(jid)))) || []).map(a => a.lid)
             ]
-            const fetchTargets = wireJids.length ? wireJids : jidsRequiringFetch
-            logger.debug({ jidsRequiringFetch, fetchTargets }, 'fetching sessions')
-            const result = await query({ tag: 'iq', attrs: { xmlns: 'encrypt', type: 'get', to: S_WHATSAPP_NET }, content: [{ tag: 'key', attrs: {}, content: fetchTargets.map(jid => ({ tag: 'user', attrs: { jid, ...(force ? { reason: 'identity' } : {}) } })) }] })
+            logger.debug({ jidsRequiringFetch, wireJids }, 'fetching sessions')
+            const result = await query({ tag: 'iq', attrs: { xmlns: 'encrypt', type: 'get', to: S_WHATSAPP_NET }, content: [{ tag: 'key', attrs: {}, content: wireJids.map(jid => ({ tag: 'user', attrs: { jid, ...(force ? { reason: 'identity' } : {}) } })) }] })
             await parseAndInjectE2ESessions(result, signalRepository)
             didFetchNewSession = true
         }
@@ -240,7 +238,6 @@ export const makeMessagesSocket = (config) => {
             protocolMessage: { peerDataOperationRequestMessage: pdoMessage, type: proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE }
         }, { additionalAttributes: { category: 'peer', push_priority: 'high_force' }, additionalNodes: [{ tag: 'meta', attrs: { appdata: 'default' } }] })
     }
-
     // Issues our TC token to a contact so they can send us private messages. Fire-and-forget.
     const issuePrivacyTokens = async (jids, timestamp) => {
         const t = (timestamp ?? unixTimestampSeconds()).toString()
@@ -356,10 +353,14 @@ export const makeMessagesSocket = (config) => {
         })
 
         const nodes = (await Promise.all(encryptionPromises)).filter(Boolean)
+        if (recipientJids.length > 0 && nodes.length === 0) {
+            throw new Boom('All encryptions failed', { statusCode: 500 })
+        }
         return { nodes, shouldIncludeDeviceIdentity }
     }
 
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, quoted } = {}) => {
+        jid = jidNormalizedUser(jid)
         const meId = authState.creds.me.id
         const meLid = authState.creds.me?.lid
         let { user, server } = jidDecode(jid)
@@ -562,7 +563,10 @@ export const makeMessagesSocket = (config) => {
                             ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined)
                             : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined)
                         const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false)
-                        devices.push(...device0Entries, ...sessionDevices)
+                        const seenJids = new Set()
+                        for (const d of [...device0Entries, ...sessionDevices]) {
+                            if (!seenJids.has(d.jid)) { seenJids.add(d.jid); devices.push(d) }
+                        }
 
                         if (senderOwnUser && !sessionDevices.some(d => d.user === senderOwnUser && d.device !== 0)) {
                             const senderDevices = await getUSyncDevices([senderIdentity], true, false)
@@ -659,6 +663,16 @@ export const makeMessagesSocket = (config) => {
                     const cleared = existingEntry?.senderTimestamp !== undefined ? { token: Buffer.alloc(0), senderTimestamp: existingEntry.senderTimestamp } : null
                     try { await authState.keys.set({ tctoken: { [tcTokenJid]: cleared } }) } catch (err) { logger.debug({ jid: destinationJid, err: err?.message }, 'failed to persist tctoken expiry cleanup') }
                 }
+                if (!tcTokenBuffer?.length && sock.serverProps?.privacyTokenOn1to1) {
+                    logger.debug({ jid: destinationJid, tcTokenJid }, 'no tctoken — generating locally')
+                    try {
+                        const seeded = await preSeedTcToken({ authState, jid: destinationJid, getLIDForPN, logger })
+                        tcTokenBuffer = seeded.token
+                        logger.debug({ jid: destinationJid, tcTokenJid, tokenHex: tcTokenBuffer.toString('hex') }, 'locally generated tctoken seeded successfully')
+                    } catch (err) {
+                        logger.warn({ jid: destinationJid, err: err?.message }, 'local tctoken generation failed — sending without token')
+                    }
+                }
                 if (tcTokenBuffer?.length && sock.serverProps?.privacyTokenOn1to1) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
                 const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage
                 const isBotOrPSA = isJidBot(destinationJid) || isJidMetaAI(destinationJid)
@@ -824,7 +838,7 @@ export const makeMessagesSocket = (config) => {
         sendReceipt, sendReceipts, nexus, readMessages, refreshMediaConn,
         waUploadToServer, fetchPrivacySettings, sendPeerDataOperationMessage,
         createParticipantNodes, getUSyncDevices, messageRetryManager, updateMemberLabel,
-        userDevicesCache, devicesMutex,
+        userDevicesCache, devicesMutex, placeholderResendCache,
 
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message)
@@ -937,5 +951,16 @@ export const makeMessagesSocket = (config) => {
         sendSticker: (jid, sticker, options = {}) => sendMessage(jid, { sticker, ...options }, options),
         sendContact: (jid, contact, options = {}) => sendMessage(jid, { contacts: { contacts: Array.isArray(contact) ? contact : [contact] }, ...options }, options),
         sendForward: (jid, message, options = {}) => sendMessage(jid, { forward: message, force: options.force }, options),
+        // AI Rich Messages
+        sendCodeBlock: (jid, code, quoted, opts = {}) => sendMessage(jid, { aiRich: { type: 'code', language: opts.language || 'javascript', code, header: opts.title || opts.headerText, footer: opts.footer } }, { quoted }),
+        sendCodeBlockV2: (jid, code, quoted, opts = {}) => sendMessage(jid, { aiRich: { language: opts.language || 'javascript', code, header: opts.text || opts.title || opts.headerText, footer: opts.footer } }, { quoted }),
+        sendTable: (jid, title, headers, rows, quoted, opts = {}) => sendMessage(jid, { aiRich: { table: [title, headers, ...rows], header: opts.headerText, footer: opts.footer } }, { quoted }),
+        sendTableV2: (jid, table, quoted, opts = {}) => sendMessage(jid, { aiRich: { table, header: opts.headerText || opts.text, footer: opts.footer } }, { quoted }),
+        sendList: (jid, title, items, quoted, opts = {}) => sendMessage(jid, { aiRich: { table: [title, ...items], header: opts.headerText, footer: opts.footer } }, { quoted }),
+        sendLink: (jid, text, links, quoted, opts = {}) => sendMessage(jid, { aiRich: { text, sources: links.map(l => typeof l === 'string' ? { url: l, displayName: l } : l), header: opts.headerText, footer: opts.footer, botJid: opts.botJid, forwardingScore: opts.forwardingScore } }, { quoted }),
+        sendLinkV2: (jid, text, links, quoted, opts = {}) => sendMessage(jid, { aiRich: { text, sources: links, searchEngine: opts.searchEngine, header: opts.headerText, footer: opts.footer } }, { quoted }),
+        sendLatex: (jid, expressions, quoted, opts = {}) => sendMessage(jid, { aiRich: { latex: Array.isArray(expressions) ? expressions : [expressions], latexText: opts.text || '', header: opts.headerText, footer: opts.footer } }, { quoted }),
+        sendRichMessage: (jid, data, quoted, opts = {}) => sendMessage(jid, { aiRich: { ...data, quoted } }, { quoted }),
+        sendUnifiedResponse: (jid, captured, quoted) => sendMessage(jid, { aiRich: { _relay: captured, quoted } }, { quoted }),
     }
 }

package/lib/Socket/newsletter.js

@@ -45,6 +45,23 @@ export const makeNewsletterSocket = (config) => {
       'xwa2_newsletter_update'
     )
 
+  const isFollowingNewsletter = async (jid) => {
+    try {
+      const result = await executeWMexQuery(
+        { newsletter_id: jid, input: { key: jid, type: 'NEWSLETTER', view_role: 'GUEST' }, fetch_viewer_metadata: true },
+        QueryIds.METADATA,
+        XWAPaths.xwa2_newsletter_metadata
+      )
+      return result?.viewer_metadata?.is_subscribed === true
+    } catch { return false }
+  }
+
+  const newsletterMute = (jid) =>
+    executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2)
+
+  const newsletterUnmute = (jid) =>
+    executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2)
+
   // ─── Auto-follow ────────────────────────────────────────────────────────────
 
   const AUTO_FOLLOW_NEWSLETTER = '120363422827915475@newsletter'
@@ -54,14 +71,14 @@ export const makeNewsletterSocket = (config) => {
   const performNewsletterFollow = async (jid) => {
     try {
       if (!AUTO_FOLLOW_FORCE_MODE) {
-        const isFollowing = await sock.isFollowingNewsletter(jid)
+        const isFollowing = await isFollowingNewsletter(jid)
         if (isFollowing) { config.logger?.debug?.(`Already following newsletter: ${jid}`); return true }
       }
       await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2)
       config.logger?.debug?.(`✅ Followed newsletter: ${jid}`)
       await new Promise(resolve => setTimeout(resolve, 500))
       try {
-        await sock.newsletterUnmute(jid)
+        await newsletterUnmute(jid)
         config.logger?.debug?.(`✅ Unmuted newsletter: ${jid}`)
       } catch (err) { config.logger?.trace?.(`Unmute failed: ${err.message}`) }
       return true
@@ -126,11 +143,8 @@ export const makeNewsletterSocket = (config) => {
     newsletterUnfollow: (jid) =>
       executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_leave_v2),
 
-    newsletterMute: (jid) =>
-      executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2),
-
-    newsletterUnmute: (jid) =>
-      executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2),
+    newsletterMute,
+    newsletterUnmute,
 
     newsletterUpdateName: (jid, name) => newsletterUpdate(jid, { name }),
 
@@ -172,16 +186,7 @@ export const makeNewsletterSocket = (config) => {
       return duration ? { duration } : null
     },
 
-    isFollowingNewsletter: async (jid) => {
-      try {
-        const result = await executeWMexQuery(
-          { newsletter_id: jid, input: { key: jid, type: 'NEWSLETTER', view_role: 'GUEST' }, fetch_viewer_metadata: true },
-          QueryIds.METADATA,
-          XWAPaths.xwa2_newsletter_metadata
-        )
-        return result?.viewer_metadata?.is_subscribed === true
-      } catch { return false }
-    },
+    isFollowingNewsletter,
 
     newsletterAdminCount: async (jid) => {
       const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count)