@queenanya/baileys 9.2.4 → 9.4.3

package/lib/Socket/messages-send.js

@@ -1,18 +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 { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.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, 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
@@ -259,6 +270,9 @@ export const makeMessagesSocket = (config) => {
      * 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,
@@ -427,14 +441,16 @@ export const makeMessagesSocket = (config) => {
         }
         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';
@@ -456,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' };
@@ -468,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;
             }
@@ -477,7 +497,7 @@ export const makeMessagesSocket = (config) => {
                 const bytes = encodeNewsletterMessage(patched);
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: {},
+                    attrs: mediaType ? { mediatype: mediaType } : {},
                     content: bytes
                 });
                 const stanza = {
@@ -494,7 +514,10 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
+            if (messages.pinInChatMessage ||
+                messages.keepInChatMessage ||
+                messages.reactionMessage ||
+                messages.protocolMessage?.editedMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
             if (isGroupOrStatus && !isRetryResend) {
@@ -770,9 +793,29 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
-            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
-            if (tcTokenBuffer) {
+            // 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',
@@ -780,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);
@@ -793,75 +940,6 @@ export const makeMessagesSocket = (config) => {
         }, meId);
         return msgId;
     };
-    const getMessageType = (message) => {
-        const normalizedMessage = normalizeMessageContent(message);
-        if (!normalizedMessage)
-            return 'text';
-        if (normalizedMessage.reactionMessage || normalizedMessage.encReactionMessage) {
-            return 'reaction';
-        }
-        if (normalizedMessage.pollCreationMessage ||
-            normalizedMessage.pollCreationMessageV2 ||
-            normalizedMessage.pollCreationMessageV3 ||
-            normalizedMessage.pollUpdateMessage) {
-            return 'poll';
-        }
-        if (normalizedMessage.eventMessage) {
-            return 'event';
-        }
-        if (getMediaType(normalizedMessage) !== '') {
-            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({
@@ -888,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,
@@ -910,7 +1015,7 @@ export const makeMessagesSocket = (config) => {
             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),
@@ -922,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})`, {
@@ -962,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,
@@ -981,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;
@@ -1008,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) {
@@ -1028,7 +1184,8 @@ export const makeMessagesSocket = (config) => {
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
                     additionalAttributes,
                     statusJidList: options.statusJidList,
-                    additionalNodes
+                    additionalNodes,
+                    AI: options.ai
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
@@ -1037,6 +1194,91 @@ export const makeMessagesSocket = (config) => {
                 }
                 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 };
         }
     };
 };