@queenanya/baileys 9.2.1 → 9.4.1

package/lib/Socket/messages-send.js

@@ -1,17 +1,29 @@
 import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
+import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
+import { execSendStatusMentions } from '../addons/from-messages-send.js';
+import { extractUnifiedResponse, generateCodeBlockContent, generateLatexContent, generateLatexImageContent, generateLatexInlineImageContent, generateListContent, generateRichMessageContent, generateTableContent, generateUnifiedResponseContent } from '../addons/message-composer.js';
+import { getButtonArgs, getButtonType, getMediaType, getMessageType } from '../addons/message-utils.js';
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
+import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
+import { areJidsSameUser, getBinaryFilteredBizBot, getBinaryFilteredButtons, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
-    const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    /**
+     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
+     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
+     */
+    const inFlightTcTokenIssuance = new Set();
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -254,6 +266,34 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
+    /**
+     * Update Member Label
+     */
+    const updateMemberLabel = (jid, memberLabel) => {
+        if (!isJidGroup(jid)) {
+            throw new Error('Jid must a group jid!');
+        }
+        return relayMessage(jid, {
+            protocolMessage: {
+                type: proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
+                memberLabel: {
+                    label: memberLabel?.slice(0, 30),
+                    labelTimestamp: unixTimestampSeconds()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    };
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
         const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
@@ -354,59 +394,63 @@ export const makeMessagesSocket = (config) => {
         const meLid = authState.creds.me?.lid;
         const meLidUser = meLid ? jidDecode(meLid)?.user : null;
         const encryptionPromises = patchedMessages.map(async ({ recipientJid: jid, message: patchedMessage }) => {
-            if (!jid)
-                return null;
-            let msgToEncrypt = patchedMessage;
-            if (dsmMessage) {
-                const { user: targetUser } = jidDecode(jid);
-                const { user: ownPnUser } = jidDecode(meId);
-                const ownLidUser = meLidUser;
-                const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
-                const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
-                if (isOwnUser && !isExactSenderDevice) {
-                    msgToEncrypt = dsmMessage;
-                    logger.debug({ jid, targetUser }, 'Using DSM for own device');
-                }
-            }
-            const bytes = encodeWAMessage(msgToEncrypt);
-            const mutexKey = jid;
-            const node = await encryptionMutex.mutex(mutexKey, async () => {
-                const { type, ciphertext } = await signalRepository.encryptMessage({
-                    jid,
-                    data: bytes
+            try {
+                if (!jid)
+                    return null;
+                let msgToEncrypt = patchedMessage;
+                if (dsmMessage) {
+                    const { user: targetUser } = jidDecode(jid);
+                    const { user: ownPnUser } = jidDecode(meId);
+                    const ownLidUser = meLidUser;
+                    const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isOwnUser && !isExactSenderDevice) {
+                        msgToEncrypt = dsmMessage;
+                        logger.debug({ jid, targetUser }, 'Using DSM for own device');
+                    }
+                }
+                const bytes = encodeWAMessage(msgToEncrypt);
+                const mutexKey = jid;
+                const node = await encryptionMutex.mutex(mutexKey, async () => {
+                    const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes });
+                    if (type === 'pkmsg') {
+                        shouldIncludeDeviceIdentity = true;
+                    }
+                    return {
+                        tag: 'to',
+                        attrs: { jid },
+                        content: [
+                            {
+                                tag: 'enc',
+                                attrs: { v: '2', type, ...(extraAttrs || {}) },
+                                content: ciphertext
+                            }
+                        ]
+                    };
                 });
-                if (type === 'pkmsg') {
-                    shouldIncludeDeviceIdentity = true;
-                }
-                return {
-                    tag: 'to',
-                    attrs: { jid },
-                    content: [
-                        {
-                            tag: 'enc',
-                            attrs: {
-                                v: '2',
-                                type,
-                                ...(extraAttrs || {})
-                            },
-                            content: ciphertext
-                        }
-                    ]
-                };
-            });
-            return node;
+                return node;
+            }
+            catch (err) {
+                logger.error({ jid, err }, 'Failed to encrypt for recipient');
+                return null;
+            }
         });
         const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+        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 }) => {
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, AI = false }) => {
         const meId = authState.creds.me.id;
         const meLid = authState.creds.me?.lid;
         const isRetryResend = Boolean(participant?.jid);
         let shouldIncludeDeviceIdentity = isRetryResend;
+        let didPushAdditional = false;
         const statusJid = 'status@broadcast';
         const { user, server } = jidDecode(jid);
         const isGroup = server === 'g.us';
+        const isPrivate = server === 's.whatsapp.net';
         const isStatus = jid === statusJid;
         const isLid = server === 'lid';
         const isNewsletter = server === 'newsletter';
@@ -419,6 +463,7 @@ export const makeMessagesSocket = (config) => {
         const destinationJid = !isStatus ? finalJid : statusJid;
         const binaryNodeContent = [];
         const devices = [];
+        let reportingMessage;
         const meMsg = {
             deviceSentMessage: {
                 destinationJid,
@@ -427,6 +472,10 @@ export const makeMessagesSocket = (config) => {
             messageContextInfo: message.messageContextInfo
         };
         const extraAttrs = {};
+        // normalizeMessageContent BEFORE transaction — exact addons pattern
+        const messages = normalizeMessageContent(message) || message;
+        const buttonType = getButtonType(messages);
+        const pollMessage = messages.pollCreationMessage || messages.pollCreationMessageV2 || messages.pollCreationMessageV3;
         if (participant) {
             if (!isGroup && !isStatus) {
                 additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
@@ -439,7 +488,7 @@ export const makeMessagesSocket = (config) => {
             });
         }
         await authState.keys.transaction(async () => {
-            const mediaType = getMediaType(message);
+            const mediaType = getMediaType(messages);
             if (mediaType) {
                 extraAttrs['mediatype'] = mediaType;
             }
@@ -448,7 +497,7 @@ export const makeMessagesSocket = (config) => {
                 const bytes = encodeNewsletterMessage(patched);
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: {},
+                    attrs: mediaType ? { mediatype: mediaType } : {},
                     content: bytes
                 });
                 const stanza = {
@@ -465,7 +514,10 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            if (normalizeMessageContent(message)?.pinInChatMessage) {
+            if (messages.pinInChatMessage ||
+                messages.keepInChatMessage ||
+                messages.reactionMessage ||
+                messages.protocolMessage?.editedMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
             if (isGroupOrStatus && !isRetryResend) {
@@ -513,6 +565,7 @@ export const makeMessagesSocket = (config) => {
                     throw new Boom('Per-jid patching is not supported in groups');
                 }
                 const bytes = encodeWAMessage(patched);
+                reportingMessage = patched;
                 const groupAddressingMode = additionalAttributes?.['addressing_mode'] || groupData?.addressingMode || 'lid';
                 const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId;
                 const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
@@ -567,6 +620,12 @@ export const makeMessagesSocket = (config) => {
                     logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation');
                 }
                 const { user: ownUser } = jidDecode(ownId);
+                if (!participant) {
+                    const patchedForReporting = await patchMessageBeforeSending(message, [jid]);
+                    reportingMessage = Array.isArray(patchedForReporting)
+                        ? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
+                        : patchedForReporting;
+                }
                 if (!isRetryResend) {
                     const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
                     devices.push({
@@ -711,9 +770,52 @@ export const makeMessagesSocket = (config) => {
                 });
                 logger.debug({ jid }, 'adding device identity');
             }
-            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
-            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
-            if (tcTokenBuffer) {
+            if (!isNewsletter &&
+                !isRetryResend &&
+                reportingMessage?.messageContextInfo?.messageSecret &&
+                shouldIncludeReportingToken(reportingMessage)) {
+                try {
+                    const encoded = encodeWAMessage(reportingMessage);
+                    const reportingKey = {
+                        id: msgId,
+                        fromMe: true,
+                        remoteJid: destinationJid,
+                        participant: participant?.jid
+                    };
+                    const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey);
+                    if (reportingNode) {
+                        ;
+                        stanza.content.push(reportingNode);
+                        logger.trace({ jid }, 'added reporting token to message');
+                    }
+                }
+                catch (error) {
+                    logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
+                }
+            }
+            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
+            const isPeerMessage = additionalAttributes?.['category'] === 'peer';
+            const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
+            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
+            const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
+            const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
+            const existingTokenEntry = contactTcTokenData[tcTokenJid];
+            let tcTokenBuffer = existingTokenEntry?.token;
+            // Treat expired tokens the same as missing — clear from cache
+            if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
+                logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
+                tcTokenBuffer = undefined;
+                const cleared = existingTokenEntry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.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) {
                 ;
                 stanza.content.push({
                     tag: 'tctoken',
@@ -721,12 +823,116 @@ export const makeMessagesSocket = (config) => {
                     content: tcTokenBuffer
                 });
             }
-            if (additionalNodes && additionalNodes.length > 0) {
+            // Inject poll/event meta node directly in relayMessage
+            // (mirrors innovators — handles direct relayMessage calls, not just sendMessage)
+            if (pollMessage || messages.eventMessage) {
+                const hasPollMeta = (additionalNodes ?? []).some((n) => n.tag === 'meta' && ('polltype' in n.attrs || 'event_type' in n.attrs));
+                if (!hasPollMeta) {
+                    const metaAttrs = messages.eventMessage
+                        ? { event_type: 'creation' }
+                        : isNewsletter
+                            ? {
+                                polltype: 'creation',
+                                contenttype: pollMessage?.pollContentType === 2 ? 'image' : 'text'
+                            }
+                            : { polltype: 'creation' };
+                    stanza.content.push({ tag: 'meta', attrs: metaAttrs });
+                }
+            }
+            // Inject <biz> node for button messages
+            // Works for: WhatsApp Messenger + WhatsApp Business, Android + iOS
+            if (!isJidNewsletter(destinationJid) && buttonType) {
+                const buttonsNode = getButtonArgs(messages);
+                const filteredButtons = getBinaryFilteredButtons(additionalNodes ? additionalNodes : []);
+                if (filteredButtons) {
+                    ;
+                    stanza.content.push(...additionalNodes);
+                    didPushAdditional = true;
+                }
+                else {
+                    ;
+                    stanza.content.push(buttonsNode);
+                }
+                // bot node: required for buttons to be interactive in private chats
+                // (independent of AI flag — matches innovators + button-helper behaviour)
+                if (isPrivate) {
+                    const botNode = { tag: 'bot', attrs: { biz_bot: '1' } };
+                    const filteredBizBot = getBinaryFilteredBizBot(additionalNodes ? additionalNodes : []);
+                    if (filteredBizBot) {
+                        if (!didPushAdditional) {
+                            ;
+                            stanza.content.push(...additionalNodes);
+                            didPushAdditional = true;
+                        }
+                    }
+                    else {
+                        ;
+                        stanza.content.push(botNode);
+                    }
+                }
+            }
+            // AI icon feature — adds bot node for non-button messages with AI flag
+            if (AI && isPrivate && !buttonType) {
+                const botNode = { tag: 'bot', attrs: { biz_bot: '1' } };
+                const filteredBizBot = getBinaryFilteredBizBot(additionalNodes ? additionalNodes : []);
+                if (filteredBizBot) {
+                    ;
+                    stanza.content.push(...additionalNodes);
+                    didPushAdditional = true;
+                }
+                else {
+                    ;
+                    stanza.content.push(botNode);
+                }
+            }
+            if (!didPushAdditional && additionalNodes && additionalNodes.length > 0) {
                 ;
                 stanza.content.push(...additionalNodes);
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
+            // Fire-and-forget: issue our token to the contact AFTER message send.
+            // WA Web skips protocol messages and PSA/bot contacts
+            const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage;
+            const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
+            if (is1on1Send &&
+                !isProtocolMsg &&
+                !isBotOrPSA &&
+                shouldSendNewTcToken(existingTokenEntry?.senderTimestamp) &&
+                !inFlightTcTokenIssuance.has(tcTokenJid)) {
+                inFlightTcTokenIssuance.add(tcTokenJid);
+                const issueTimestamp = unixTimestampSeconds();
+                const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping);
+                resolveIssuanceJid(destinationJid, sock.serverProps.lidTrustedTokenIssueToLid, getLIDForPN, getPNForLID)
+                    .then(issueJid => issuePrivacyTokens([issueJid], issueTimestamp))
+                    .then(async (result) => {
+                    await storeTcTokensFromIqResult({
+                        result,
+                        fallbackJid: tcTokenJid,
+                        keys: authState.keys,
+                        getLIDForPN
+                    });
+                    const currentData = await authState.keys.get('tctoken', [tcTokenJid]);
+                    const currentEntry = currentData[tcTokenJid];
+                    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid]);
+                    await authState.keys.set({
+                        tctoken: {
+                            [tcTokenJid]: {
+                                token: Buffer.alloc(0),
+                                ...currentEntry,
+                                senderTimestamp: issueTimestamp
+                            },
+                            ...indexWrite
+                        }
+                    });
+                })
+                    .catch(err => {
+                    logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed');
+                })
+                    .finally(() => {
+                    inFlightTcTokenIssuance.delete(tcTokenJid);
+                });
+            }
             // Add message to retry cache if enabled
             if (messageRetryManager && !participant) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
@@ -734,66 +940,6 @@ export const makeMessagesSocket = (config) => {
         }, meId);
         return msgId;
     };
-    const getMessageType = (message) => {
-        if (message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3) {
-            return 'poll';
-        }
-        if (message.eventMessage) {
-            return 'event';
-        }
-        if (getMediaType(message) !== '') {
-            return 'media';
-        }
-        return 'text';
-    };
-    const getMediaType = (message) => {
-        if (message.imageMessage) {
-            return 'image';
-        }
-        else if (message.videoMessage) {
-            return message.videoMessage.gifPlayback ? 'gif' : 'video';
-        }
-        else if (message.audioMessage) {
-            return message.audioMessage.ptt ? 'ptt' : 'audio';
-        }
-        else if (message.contactMessage) {
-            return 'vcard';
-        }
-        else if (message.documentMessage) {
-            return 'document';
-        }
-        else if (message.contactsArrayMessage) {
-            return 'contact_array';
-        }
-        else if (message.liveLocationMessage) {
-            return 'livelocation';
-        }
-        else if (message.stickerMessage) {
-            return 'sticker';
-        }
-        else if (message.listMessage) {
-            return 'list';
-        }
-        else if (message.listResponseMessage) {
-            return 'list_response';
-        }
-        else if (message.buttonsResponseMessage) {
-            return 'buttons_response';
-        }
-        else if (message.orderMessage) {
-            return 'order';
-        }
-        else if (message.productMessage) {
-            return 'product';
-        }
-        else if (message.interactiveResponseMessage) {
-            return 'native_flow_response';
-        }
-        else if (message.groupInviteMessage) {
-            return 'url';
-        }
-        return '';
-    };
     const getPrivacyTokens = async (jids) => {
         const t = unixTimestampSeconds().toString();
         const result = await query({
@@ -820,11 +966,38 @@ export const makeMessagesSocket = (config) => {
         });
         return result;
     };
+    const issuePrivacyTokens = async (jids, timestamp) => {
+        const t = (timestamp ?? unixTimestampSeconds()).toString();
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'privacy'
+            },
+            content: [
+                {
+                    tag: 'tokens',
+                    attrs: {},
+                    content: jids.map(jid => ({
+                        tag: 'token',
+                        attrs: {
+                            jid: jidNormalizedUser(jid),
+                            t,
+                            type: 'trusted_contact'
+                        }
+                    }))
+                }
+            ]
+        });
+        return result;
+    };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
     return {
         ...sock,
         getPrivacyTokens,
+        issuePrivacyTokens,
         assertSessions,
         relayMessage,
         sendReceipt,
@@ -837,11 +1010,12 @@ export const makeMessagesSocket = (config) => {
         createParticipantNodes,
         getUSyncDevices,
         messageRetryManager,
+        updateMemberLabel,
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message);
             const mediaKey = content.mediaKey;
             const meId = authState.creds.me.id;
-            const node = await encryptMediaRetryRequest(message.key, mediaKey, meId);
+            const node = encryptMediaRetryRequest(message.key, mediaKey, meId);
             let error = undefined;
             await Promise.all([
                 sendNode(node),
@@ -853,7 +1027,7 @@ export const makeMessagesSocket = (config) => {
                         }
                         else {
                             try {
-                                const media = await decryptMediaRetryData(result.media, mediaKey, result.key.id);
+                                const media = decryptMediaRetryData(result.media, mediaKey, result.key.id);
                                 if (media.result !== proto.MediaRetryNotification.ResultType.SUCCESS) {
                                     const resultStr = proto.MediaRetryNotification.ResultType[media.result];
                                     throw new Boom(`Media re-upload failed by device (${resultStr})`, {
@@ -893,6 +1067,48 @@ export const makeMessagesSocket = (config) => {
                     : disappearingMessagesInChat;
                 await groupToggleEphemeral(jid, value);
             }
+            else if (typeof content === 'object' && 'album' in content && content.album) {
+                // Album message — matches addons prepareAlbumMessageContent
+                const albumItems = content.album;
+                const albumMsg = generateWAMessageFromContent(jid, {
+                    albumMessage: {
+                        expectedImageCount: albumItems.filter((i) => 'image' in i).length,
+                        expectedVideoCount: albumItems.filter((i) => 'video' in i).length
+                    }
+                }, { userJid, ...options });
+                await relayMessage(jid, albumMsg.message, { messageId: albumMsg.key.id });
+                const mediaMsgs = [];
+                for (const item of albumItems) {
+                    const mediaContent = 'image' in item ? { image: item.image, ...item } : { video: item.video, ...item };
+                    const mediaMsg = await generateWAMessage(jid, mediaContent, {
+                        logger,
+                        userJid,
+                        upload: async (encFilePath, opts) => {
+                            const up = await waUploadToServer(encFilePath, { ...opts, newsletter: isJidNewsletter(jid) });
+                            return up;
+                        },
+                        ...options
+                    });
+                    if (mediaMsg.message) {
+                        mediaMsg.message.messageContextInfo = {
+                            messageSecret: randomBytes(32),
+                            messageAssociation: {
+                                associationType: 1,
+                                parentMessageKey: albumMsg.key
+                            }
+                        };
+                    }
+                    mediaMsgs.push(mediaMsg);
+                    await delay(options.delay || 500);
+                    await relayMessage(jid, mediaMsg.message, {
+                        messageId: mediaMsg.key.id,
+                        useCachedGroupMetadata: options.useCachedGroupMetadata,
+                        statusJidList: options.statusJidList,
+                        AI: options.ai
+                    });
+                }
+                return mediaMsgs[0];
+            }
             else {
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,
@@ -912,7 +1128,11 @@ export const makeMessagesSocket = (config) => {
                     upload: waUploadToServer,
                     mediaCache: config.mediaCache,
                     options: config.options,
-                    messageId: generateMessageIDV2(sock.user?.id),
+                    messageId: (('groupStatus' in content && content.groupStatus) ||
+                        ('cards' in content && content?.cards)) &&
+                        !options.messageId
+                        ? `4NY4W3B${randomBytes(16).toString('hex').toUpperCase()}`
+                        : generateMessageIDV2(sock.user?.id),
                     ...options
                 });
                 const isEventMsg = 'event' in content && !!content.event;
@@ -939,11 +1159,16 @@ export const makeMessagesSocket = (config) => {
                     additionalAttributes.edit = '2';
                 }
                 else if (isPollMessage) {
+                    // Newsletter polls need a contenttype attr ('image' or 'text')
+                    // matching innovators behaviour for cross-client compatibility
+                    const pollAttrs = { polltype: 'creation' };
+                    if (isJidNewsletter(jid)) {
+                        const pollContent = content.poll;
+                        pollAttrs.contenttype = pollContent?.pollContentType === 2 ? 'image' : 'text';
+                    }
                     additionalNodes.push({
                         tag: 'meta',
-                        attrs: {
-                            polltype: 'creation'
-                        }
+                        attrs: pollAttrs
                     });
                 }
                 else if (isEventMsg) {
@@ -959,15 +1184,101 @@ export const makeMessagesSocket = (config) => {
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
                     additionalAttributes,
                     statusJidList: options.statusJidList,
-                    additionalNodes
+                    additionalNodes,
+                    AI: options.ai
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
-                        await processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
                 return fullMsg;
             }
+        },
+        // Logic lives in addons/from-messages-send.ts → execSendStatusMentions
+        sendStatusMentions: async (content, jids = []) => {
+            return execSendStatusMentions(content, jids, {
+                meId: authState.creds.me.id,
+                logger,
+                groupMetadata: sock.groupMetadata,
+                cachedGroupMetadata: config.cachedGroupMetadata,
+                relayMessage,
+                waUploadToServer,
+                getUrlInfo,
+                config,
+                linkPreviewImageThumbnailWidth,
+                generateHighQualityLinkPreview,
+                httpRequestOptions
+            });
+        },
+        /**
+         * Send a rich table via botForwardedMessage → richResponseMessage.
+         */
+        sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
+            const { message, messageId } = generateTableContent(title, headers, rows, quoted, options);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Send a rich list (single-column table).
+         */
+        sendList: async (jid, title, items, quoted, options = {}) => {
+            const { message, messageId } = generateListContent(title, items, quoted, options);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Send a syntax-highlighted code block.
+         */
+        sendCodeBlock: async (jid, code, quoted, options = {}) => {
+            const { message, messageId } = generateCodeBlockContent(code, quoted, options);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Send a LaTeX expression as text (no image rendering).
+         */
+        sendLatex: async (jid, quoted, options) => {
+            const { message, messageId } = generateLatexContent(quoted, options);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Render LaTeX to PNG images, upload, and send.
+         */
+        sendLatexImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
+            const { message, messageId } = await generateLatexImageContent(quoted, options, uploadFn, renderLatexToPng);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Render LaTeX to PNG inline image blocks, upload, and send.
+         */
+        sendLatexInlineImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
+            const { message, messageId } = await generateLatexInlineImageContent(quoted, options, uploadFn, renderLatexToPng);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Send a fully custom rich message from a raw submessages array.
+         */
+        sendRichMessage: async (jid, submessages, quoted) => {
+            const { message, messageId } = generateRichMessageContent(submessages, quoted);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        /**
+         * Capture the unifiedResponse payload from an incoming Meta AI message.
+         * Returns null if the message is not a rich response.
+         */
+        extractUnifiedResponse,
+        /**
+         * Re-send a captured unifiedResponse to a new JID.
+         */
+        sendUnifiedResponse: async (jid, quoted, captured) => {
+            const { message, messageId } = generateUnifiedResponseContent(quoted, captured);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
         }
     };
 };