@systemzero/baileys 1.0.0

package/lib/Socket/messages-send.js

@@ -0,0 +1,1152 @@
+import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
+import { proto } from '../../WAProto/index.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, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import * as Utils 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 { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeNewsletterSocket } from './newsletter.js';
+import Hzxx from './hzxx.js';
+import { randomBytes } from 'crypto';
+import normalizeSystem from './normalize.js';
+const META_AI_BOT_JID        = '867051314767696@bot';
+const META_AI_BOT_NAME       = 'Meta AI';
+const META_AI_CREATOR_NAME   = 'Meta';
+const FORWARD_ORIGIN_META_AI = 4;
+const BOT_ENTRY_1ON1         = 29;
+const BOT_ENTRY_GROUP        = 30;
+const KEYWORD_HIGHLIGHT = 1;
+const STRING_HIGHLIGHT  = 3;
+const NUMBER_HIGHLIGHT  = 4;
+const CODE_TOKEN_REGEX = /\b(?:async|await|break|case|catch|class|const|continue|default|delete|do|else|export|false|finally|for|from|function|if|import|in|instanceof|let|new|null|of|return|static|super|switch|this|throw|true|try|typeof|undefined|var|void|while|with|yield)\b|\b\d+(?:\.\d+)?\b|(["'`])(?:\\.|(?!\1)[\s\S])*\1/g;
+
+function _randomId(prefix = 'systemzr') {
+return `${prefix}-${Date.now()}-${randomBytes(6).toString('hex')}`; }
+
+function _getHighlightType(token) {
+    if (/^["'`]/.test(token)) return STRING_HIGHLIGHT;
+    if (/^\d/.test(token))    return NUMBER_HIGHLIGHT;
+    return KEYWORD_HIGHLIGHT; }
+
+function _buildCodeBlocks(codeText) {
+    const text   = String(codeText || '');
+    const blocks = [];
+    let lastIndex = 0;
+    for (const match of text.matchAll(CODE_TOKEN_REGEX)) {
+        const token = match[0];
+        const index = match.index ?? 0;
+
+        if (index > lastIndex) blocks.push({ codeContent: text.slice(lastIndex, index) });
+        blocks.push({ highlightType: _getHighlightType(token), codeContent: token });
+        lastIndex = index + token.length;
+    }
+    if (lastIndex < text.length) blocks.push({ codeContent: text.slice(lastIndex) });
+    return blocks.length ? blocks : [{ codeContent: text }];
+}
+
+function _encodeUnified(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64');
+}
+
+function _metaAiContext(remoteJid) {
+    return {
+        isForwarded: true,
+        forwardingScore: 1,
+        forwardOrigin: FORWARD_ORIGIN_META_AI,
+        forwardedAiBotMessageInfo: {
+            botName:     META_AI_BOT_NAME,
+            botJid:      META_AI_BOT_JID,
+            creatorName: META_AI_CREATOR_NAME,
+        },
+        botMessageSharingInfo: {
+            botEntryPointOrigin: String(remoteJid || '').endsWith('@g.us') ? BOT_ENTRY_GROUP : BOT_ENTRY_1ON1,
+            forwardScore: 1,
+        },
+    };
+}
+
+function _buildBotMetadata(extraCapabilities = []) {
+    return {
+        modelMetadata: { modelType: 'LLAMA_PROD', premiumModelStatus: 'AVAILABLE' },
+        botAgeCollectionMetadata: {},
+        botResponseId: _randomId('systemzr-bot'),
+        verificationMetadata: { proofs: [] },
+        botInfrastructureDiagnostics: {},
+        capabilityMetadata: {
+            capabilities: [
+                'RICH_RESPONSE_STRUCTURED_RESPONSE',
+                'RICH_RESPONSE_UNIFIED_RESPONSE',
+                'RICH_RESPONSE_UNIFIED_TEXT_COMPONENT',
+                'SESSION_TRANSPARENCY_SYSTEM_MESSAGE',
+                ...extraCapabilities,
+            ],
+        },
+    };
+}
+
+function _buildUnifiedSection(submessage) {
+    if (submessage.messageType === 2) {
+        return {
+            view_model: {
+                primitive: { text: submessage.messageText, __typename: 'GenAIMarkdownTextUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel',
+            },
+        };
+    }
+    if (submessage.messageType === 4) {
+        return {
+            view_model: {
+                primitive: {
+                    rows: submessage.tableMetadata.rows.map(row => ({
+                        is_header: !!row.isHeading,
+                        cells: row.items.map(value => String(value ?? ''))
+                    })),
+                    __typename: 'GenATableUXPrimitive'
+                },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        };
+    }
+    if (submessage.messageType === 5) {
+        return {
+            view_model: {
+                primitive: {
+                    language: submessage.codeMetadata.codeLanguage,
+                    code_blocks: submessage.codeMetadata.codeBlocks.map((b) => ({
+                        content: String(b.codeContent || ''),
+                        type: (() => {
+                            switch (b.highlightType) {
+                                case KEYWORD_HIGHLIGHT: return 'KEYWORD';
+                                case STRING_HIGHLIGHT:  return 'STR';
+                                case NUMBER_HIGHLIGHT:  return 'NUMBER';
+                                default:               return 'DEFAULT';
+                            }
+                        })(),
+                    })),
+                    __typename: 'GenAICodeUXPrimitive',
+                },
+                __typename: 'GenAISingleLayoutViewModel',
+            },
+        };
+    }
+    return null;
+}
+
+function _buildRichResponse(submessages, remoteJid) {
+    const base = {
+        messageType: 1,
+        submessages,
+        unifiedResponse: {
+            data: _encodeUnified({
+                response_id: _randomId('systemzr'),
+                sections: submessages.map(_buildUnifiedSection).filter(Boolean),
+            }),
+        },
+    };
+    return { ...base, contextInfo: _metaAiContext(remoteJid) };
+}
+
+function makeText(text) { return { messageType: 2, messageText: String(text || '') }; }
+function makeCode(language, codeText) { return { messageType: 5, codeMetadata: { codeLanguage: language || 'text', codeBlocks: _buildCodeBlocks(codeText) } }; }
+function makeList(items = []) { return { messageType: 2, messageText: items.map((i) => `- ${i}`).join('\n') }; }
+function makeTable(rows = []) {
+    return {
+        messageType: 4,
+        tableMetadata: {
+            rows: rows.map((items, index) => ({
+                items: items.map(value => String(value ?? '')),
+                isHeading: index === 0
+            }))
+        }
+    };
+}
+
+const getButtonArgs = (message) => {
+    const nativeFlow = message.interactiveMessage?.nativeFlowMessage;
+    const stickerPack = message.interactiveMessage?.stickerPackMessage;
+    const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+    const nativeFlowSpecials = [
+        'mpm', 'cta_catalog', 'send_location',
+        'call_permission_request', 'wa_payment_transaction_details',
+        'automated_greeting_message_view_catalog'
+    ];
+    if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+        return {
+            tag: 'biz', 
+            attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+        }; 
+    } else if (stickerPack) {
+        return {
+            tag: 'biz',
+            attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: unixTimestampSeconds().toString() },
+            content: [{
+                tag: 'interactive',
+                attrs: { type: 'sticker_pack', v: '1' },
+                content: [{ tag: 'sticker_pack', attrs: { id: stickerPack.stickerPackId } }]
+            }]
+        };
+    } else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
+        return {
+            tag: 'biz',
+            attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: unixTimestampSeconds().toString() }, 
+            content: [{
+                tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+            }, { tag: 'quality_control', attrs: { source_type: 'third_party' } }]
+        };
+    } else if (nativeFlow || message.buttonsMessage) {
+        return {
+            tag: 'biz', 
+            attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: unixTimestampSeconds().toString() }, 
+            content: [{
+                tag: 'interactive', attrs: { type: 'native_flow', v: '1' }, 
+                content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+            }, { tag: 'quality_control', attrs: { source_type: 'third_party' } }]
+        };
+    } else if (message.listMessage) {
+        return {
+            tag: 'biz', 
+            attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: unixTimestampSeconds().toString() }, 
+            content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }, { tag: 'quality_control', attrs: { source_type: 'third_party' } }]
+        };
+    } else {
+        return { tag: 'biz', attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: unixTimestampSeconds().toString() } };
+    }
+};
+
+const getButtonType = (message) => {
+    if (message.listMessage) return 'list';
+    else if (message.buttonsMessage) return 'buttons';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_and_pay') return 'review_and_pay';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_order') return 'review_order';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_info') return 'payment_info';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_status') return 'payment_status';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_method') return 'payment_method';
+    else if (message.interactiveMessage && message.interactiveMessage?.nativeFlowMessage) return 'interactive';
+    else if (message.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+    else if (message.interactiveMessage?.stickerPackMessage) return 'sticker_pack';
+};
+
+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;
+    normalizeSystem.bindSocket(sock, config.store);
+    const userDevicesCache = config.userDevicesCache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
+            useClones: false
+        });
+    const peerSessionsCache = new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
+        useClones: false
+    });
+    
+    const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
+    const encryptionMutex = makeKeyedMutex();
+    let mediaConn;
+    
+    const refreshMediaConn = async (forceGet = false) => {
+        const media = await mediaConn;
+        if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
+            mediaConn = (async () => {
+                const result = await query({
+                    tag: 'iq',
+                    attrs: {
+                        type: 'set',
+                        xmlns: 'w:m',
+                        to: S_WHATSAPP_NET
+                    },
+                    content: [{ tag: 'media_conn', attrs: {} }]
+                });
+                const mediaConnNode = getBinaryNodeChild(result, 'media_conn');
+                const node = {
+                    hosts: getBinaryNodeChildren(mediaConnNode, 'host').map(({ attrs }) => ({
+                        hostname: attrs.hostname,
+                        maxContentLengthBytes: +attrs.maxContentLengthBytes
+                    })),
+                    auth: mediaConnNode.attrs.auth,
+                    ttl: +mediaConnNode.attrs.ttl,
+                    fetchDate: new Date()
+                };
+                logger.debug('fetched media conn');
+                return node;
+            })();
+        }
+        return mediaConn;
+    };
+
+    const sendReceipt = async (jid, participant, messageIds, type) => {
+        if (!messageIds || messageIds.length === 0) {
+            throw new Boom('missing ids in receipt');
+        }
+        const node = { tag: 'receipt', attrs: { id: messageIds[0] } };
+        const isReadReceipt = type === 'read' || type === 'read-self';
+        if (isReadReceipt) {
+            node.attrs.t = unixTimestampSeconds().toString();
+        }
+        if (type === 'sender' && (isPnUser(jid) || isLidUser(jid))) {
+            node.attrs.recipient = jid;
+            node.attrs.to = participant;
+        } else {
+            node.attrs.to = jid;
+            if (participant) {
+                node.attrs.participant = participant;
+            }
+        }
+        if (type) node.attrs.type = type;
+        
+        const remainingMessageIds = messageIds.slice(1);
+        if (remainingMessageIds.length) {
+            node.content = [{
+                tag: 'list', attrs: {},
+                content: remainingMessageIds.map(id => ({ tag: 'item', attrs: { id } }))
+            }];
+        }
+        logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages');
+        await sendNode(node);
+    };
+
+    const sendReceipts = async (keys, type) => {
+        const recps = aggregateMessageKeysNotFromMe(keys);
+        for (const { jid, participant, messageIds } of recps) {
+            await sendReceipt(jid, participant, messageIds, type);
+        }
+    };
+
+    const readMessages = async (keys) => {
+        const privacySettings = await fetchPrivacySettings();
+        const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self';
+        await sendReceipts(keys, readType);
+    };
+
+    const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
+        const deviceResults = [];
+        if (!useCache) logger.debug('not using cache for devices');
+        const toFetch = [];
+        const jidsWithUser = jids
+            .map(jid => {
+            const decoded = jidDecode(jid);
+            const user = decoded?.user;
+            const device = decoded?.device;
+            const isExplicitDevice = typeof device === 'number' && device >= 0;
+            if (isExplicitDevice && user) {
+                deviceResults.push({ user, device, jid });
+                return null;
+            }
+            jid = jidNormalizedUser(jid);
+            return { jid, user };
+        }).filter(jid => jid !== null);
+        
+        let mgetDevices;
+        if (useCache && userDevicesCache.mget) {
+            const usersToFetch = jidsWithUser.map(j => j?.user).filter(Boolean);
+            mgetDevices = await userDevicesCache.mget(usersToFetch);
+        }
+        for (const { jid, user } of jidsWithUser) {
+            if (useCache) {
+                const devices = mgetDevices?.[user] || (userDevicesCache.mget ? undefined : (await userDevicesCache.get(user)));
+                if (devices) {
+                    const devicesWithJid = devices.map(d => ({ ...d, jid: jidEncode(d.user, d.server, d.device) }));
+                    deviceResults.push(...devicesWithJid);
+                    logger.trace({ user }, 'using cache for devices');
+                } else {
+                    toFetch.push(jid);
+                }
+            } else {
+                toFetch.push(jid);
+            }
+        }
+        if (!toFetch.length) return deviceResults;
+        
+        const requestedLidUsers = new Set();
+        for (const jid of toFetch) {
+            if (isLidUser(jid) || isHostedLidUser(jid)) {
+                const user = jidDecode(jid)?.user;
+                if (user) requestedLidUsers.add(user);
+            }
+        }
+        
+        const query = new USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol();
+        for (const jid of toFetch) query.withUser(new USyncUser().withId(jid));
+        
+        const result = await sock.executeUSyncQuery(query);
+        if (result) {
+            const lidResults = result.list.filter(a => !!a.lid);
+            if (lidResults.length > 0) {
+                logger.trace('Storing LID maps from device call');
+                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, true);
+                } catch (e) {
+                    logger.warn({ e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs');
+                }
+            }
+            const extracted = extractDeviceJids(result?.list, authState.creds.me.id, authState.creds.me.lid, ignoreZeroDevices);
+            const deviceMap = {};
+            for (const item of extracted) {
+                deviceMap[item.user] = deviceMap[item.user] || [];
+                deviceMap[item.user]?.push(item);
+            }
+            for (const [user, userDevices] of Object.entries(deviceMap)) {
+                const isLidUser = requestedLidUsers.has(user);
+                for (const item of userDevices) {
+                    const finalJid = isLidUser ? jidEncode(user, item.server, item.device) : jidEncode(item.user, item.server, item.device);
+                    deviceResults.push({ ...item, jid: finalJid });
+                }
+            }
+            if (userDevicesCache.mset) {
+                await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
+            } else {
+                for (const key in deviceMap) {
+                    if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key]);
+                }
+            }
+            const userDeviceUpdates = {};
+            for (const [userId, devices] of Object.entries(deviceMap)) {
+                if (devices && devices.length > 0) {
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
+                }
+            }
+            if (Object.keys(userDeviceUpdates).length > 0) {
+                try {
+                    await authState.keys.set({ 'device-list': userDeviceUpdates });
+                } catch (error) {
+                    logger.warn({ error }, 'failed to store user device lists');
+                }
+            }
+        }
+        return deviceResults;
+    };
+
+    const assertSessions = async (jids, force) => {
+        let didFetchNewSession = false;
+        const uniqueJids = [...new Set(jids)];
+        const jidsRequiringFetch = [];
+        logger.debug({ jids }, 'assertSessions call with jids');
+        for (const jid of uniqueJids) {
+            const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+            const cachedSession = peerSessionsCache.get(signalId);
+            if (cachedSession !== undefined) {
+                if (cachedSession && !force) continue;
+            } else {
+                const sessionValidation = await signalRepository.validateSession(jid);
+                const hasSession = sessionValidation.exists;
+                peerSessionsCache.set(signalId, hasSession);
+                if (hasSession && !force) continue;
+            }
+            jidsRequiringFetch.push(jid);
+        }
+        if (jidsRequiringFetch.length) {
+            const wireJids = [
+                ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
+                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
+            ];
+            const result = await query({
+                tag: 'iq',
+                attrs: { xmlns: 'encrypt', type: 'get', to: S_WHATSAPP_NET },
+                content: [{
+                    tag: 'key', attrs: {},
+                    content: wireJids.map(jid => {
+                        const attrs = { jid };
+                        if (force) attrs.reason = 'identity';
+                        return { tag: 'user', attrs };
+                    })
+                }]
+            });
+            await parseAndInjectE2ESessions(result, signalRepository);
+            didFetchNewSession = true;
+            for (const wireJid of wireJids) {
+                const signalId = signalRepository.jidToSignalProtocolAddress(wireJid);
+                peerSessionsCache.set(signalId, true);
+            }
+        }
+        return didFetchNewSession;
+    };
+
+    const sendPeerDataOperationMessage = async (pdoMessage) => {
+        if (!authState.creds.me?.id) throw new Boom('Not authenticated');
+        const protocolMessage = {
+            protocolMessage: {
+                peerDataOperationRequestMessage: pdoMessage,
+                type: proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
+            }
+        };
+        const meJid = jidNormalizedUser(authState.creds.me.id);
+        const msgId = await relayMessage(meJid, protocolMessage, {
+            additionalAttributes: { category: 'peer', push_priority: 'high_force' },
+            additionalNodes: [{ tag: 'meta', attrs: { appdata: 'default' } }]
+        });
+        return msgId;
+    };
+
+    const createParticipantNodes = async (recipientJids, message, extraAttrs, dsmMessage) => {
+        if (!recipientJids.length) return { nodes: [], shouldIncludeDeviceIdentity: false };
+        const patched = await patchMessageBeforeSending(message, recipientJids);
+        const patchedMessages = Array.isArray(patched) ? patched : recipientJids.map(jid => ({ recipientJid: jid, message: patched }));
+        let shouldIncludeDeviceIdentity = false;
+        const meId = authState.creds.me.id;
+        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;
+            }
+            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 }]
+                };
+            });
+            return node;
+        });
+        const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+        return { nodes, shouldIncludeDeviceIdentity };
+    };
+
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, AI = true }) => {
+        const meId = authState.creds.me.id;
+        const meLid = authState.creds.me?.lid;
+        const isRetryResend = Boolean(participant?.jid);
+        let shouldIncludeDeviceIdentity = isRetryResend;
+        const statusJid = 'status@broadcast';
+        const { user, server } = jidDecode(jid);
+        const isGroup = server === 'g.us';
+        const isStatus = jid === statusJid;
+        const isLid = server === 'lid';
+        const isNewsletter = server === 'newsletter';
+        const isGroupOrStatus = isGroup || isStatus;
+        const finalJid = jid;
+        msgId = msgId || generateMessageIDV2(meId);
+        useUserDevicesCache = useUserDevicesCache !== false;
+        useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
+        const participants = [];
+        const destinationJid = !isStatus ? finalJid : statusJid;
+        const binaryNodeContent = [];
+        const devices = [];
+        const meMsg = { deviceSentMessage: { destinationJid, message }, messageContextInfo: message.messageContextInfo };
+        const extraAttrs = {};
+        
+        if (participant) {
+            if (!isGroup && !isStatus) additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
+            const { user, device } = jidDecode(participant.jid);
+            devices.push({ user, device, jid: participant.jid });
+        }
+        
+        await authState.keys.transaction(async () => {
+            const mediaType = getMediaType(message);
+            if (mediaType) extraAttrs['mediatype'] = mediaType;
+            if (isNewsletter) {
+                const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
+                const bytes = encodeNewsletterMessage(patched);
+                binaryNodeContent.push({ tag: 'plaintext', attrs: {}, content: bytes });
+                const stanza = {
+                    tag: 'message',
+                    attrs: { to: jid, id: msgId, type: getMessageType(message), ...(additionalAttributes || {}) },
+                    content: binaryNodeContent
+                };
+                await sendNode(stanza);
+                return;
+            }
+            if (normalizeMessageContent(message)?.pinInChatMessage) {
+                extraAttrs['decrypt-fail'] = 'hide';
+            }
+            if (isGroupOrStatus && !isRetryResend) {
+                const [groupData, senderKeyMap] = await Promise.all([
+                    (async () => {
+                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
+                        if (!groupData && !isStatus) groupData = await groupMetadata(jid);
+                        return groupData;
+                    })(),
+                    (async () => {
+                        if (!participant && !isStatus) {
+                            const result = await authState.keys.get('sender-key-memory', [jid]);
+                            return result[jid] || {};
+                        }
+                        return {};
+                    })()
+                ]);
+                const participantsList = groupData ? groupData.participants.map(p => p.id) : [];
+                if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
+                    additionalAttributes = { ...additionalAttributes, expiration: groupData.ephemeralDuration.toString() };
+                }
+                if (isStatus && statusJidList) participantsList.push(...statusJidList);
+                const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
+                devices.push(...additionalDevices);
+                if (isGroup) {
+                    additionalAttributes = { ...additionalAttributes, addressing_mode: groupData?.addressingMode || 'lid' };
+                }
+                const patched = await patchMessageBeforeSending(message);
+                if (Array.isArray(patched)) throw new Boom('Per-jid patching is not supported in groups');
+                const bytes = encodeWAMessage(patched);
+                const groupAddressingMode = additionalAttributes?.['addressing_mode'] || groupData?.addressingMode || 'lid';
+                const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId;
+                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
+                    group: destinationJid, data: bytes, meId: groupSenderIdentity
+                });
+                const senderKeyRecipients = [];
+                for (const device of devices) {
+                    const deviceJid = device.jid;
+                    const hasKey = !!senderKeyMap[deviceJid];
+                    if ((!hasKey || !!participant) && !isHostedLidUser(deviceJid) && !isHostedPnUser(deviceJid) && device.device !== 99) {
+                        senderKeyRecipients.push(deviceJid);
+                        senderKeyMap[deviceJid] = true;
+                    }
+                }
+                if (senderKeyRecipients.length) {
+                    const senderKeyMsg = {
+                        senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid }
+                    };
+                    await assertSessions(senderKeyRecipients);
+                    const result = await createParticipantNodes(senderKeyRecipients, senderKeyMsg, extraAttrs);
+                    shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || result.shouldIncludeDeviceIdentity;
+                    participants.push(...result.nodes);
+                }
+                binaryNodeContent.push({ tag: 'enc', attrs: { v: '2', type: 'skmsg', ...extraAttrs }, content: ciphertext });
+                await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
+            } else {
+                let ownId = meId;
+                if (isLid && meLid) ownId = meLid;
+                const { user: ownUser } = jidDecode(ownId);
+                if (!isRetryResend) {
+                    const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                    devices.push({ user, device: 0, jid: jidEncode(user, targetUserServer, 0) });
+                    if (user !== ownUser) {
+                        const ownUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                        const ownUserForAddressing = isLid && meLid ? jidDecode(meLid).user : jidDecode(meId).user;
+                        devices.push({ user: ownUserForAddressing, device: 0, jid: jidEncode(ownUserForAddressing, ownUserServer, 0) });
+                    }
+                    if (additionalAttributes?.['category'] !== 'peer') {
+                        devices.length = 0;
+                        const senderIdentity = isLid && meLid ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined) : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined);
+                        const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false);
+                        devices.push(...sessionDevices);
+                    }
+                }
+                const allRecipients = [];
+                const meRecipients = [];
+                const otherRecipients = [];
+                const { user: mePnUser } = jidDecode(meId);
+                const { user: meLidUser } = meLid ? jidDecode(meLid) : { user: null };
+                for (const { user, jid } of devices) {
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isExactSenderDevice) continue;
+                    const isMe = user === mePnUser || user === meLidUser;
+                    if (isMe) meRecipients.push(jid);
+                    else otherRecipients.push(jid);
+                    allRecipients.push(jid);
+                }
+                await assertSessions(allRecipients);
+                const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
+                    createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
+                    createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
+                ]);
+                participants.push(...meNodes);
+                participants.push(...otherNodes);
+                if (meRecipients.length > 0 || otherRecipients.length > 0) {
+                    extraAttrs['phash'] = generateParticipantHashV2([...meRecipients, ...otherRecipients]);
+                }
+                shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2;
+            }
+            if (isRetryResend) {
+                const isParticipantLid = isLidUser(participant.jid);
+                const isMe = areJidsSameUser(participant.jid, isParticipantLid ? meLid : meId);
+                const encodedMessageToSend = isMe ? encodeWAMessage({ deviceSentMessage: { destinationJid, message } }) : encodeWAMessage(message);
+                const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({ data: encodedMessageToSend, jid: participant.jid });
+                binaryNodeContent.push({ tag: 'enc', attrs: { v: '2', type, count: participant.count.toString() }, content: encryptedContent });
+            }
+            if (participants.length) {
+                if (additionalAttributes?.['category'] === 'peer') {
+                    const peerNode = participants[0]?.content?.[0];
+                    if (peerNode) binaryNodeContent.push(peerNode);
+                } else {
+                    binaryNodeContent.push({ tag: 'participants', attrs: {}, content: participants });
+                }
+            }
+            const stanza = {
+                tag: 'message',
+                attrs: { id: msgId, to: destinationJid, type: getMessageType(message), ...(additionalAttributes || {}) },
+                content: binaryNodeContent
+            };
+            if (participant) {
+                if (isJidGroup(destinationJid)) {
+                    stanza.attrs.to = destinationJid;
+                    stanza.attrs.participant = participant.jid;
+                } else if (areJidsSameUser(participant.jid, meId)) {
+                    stanza.attrs.to = participant.jid;
+                    stanza.attrs.recipient = destinationJid;
+                } else {
+                    stanza.attrs.to = participant.jid;
+                }
+            } else {
+                stanza.attrs.to = destinationJid;
+            }
+            if (shouldIncludeDeviceIdentity) {
+                stanza.content.push({ tag: 'device-identity', attrs: {}, content: encodeSignedDeviceIdentity(authState.creds.account, true) });
+            }
+            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
+            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
+            if (tcTokenBuffer) {
+                stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer });
+            }
+            const messages = normalizeMessageContent(message) || message;
+            const buttonType = getButtonType(messages);
+            let didPushAdditional = false;
+            const isChatPrivate = !isJidGroup(destinationJid) && destinationJid !== 'status@broadcast' && !destinationJid.includes('newsletter');
+
+            if (AI && isChatPrivate) {
+                const botNode = { tag: 'bot', attrs: { biz_bot: '1' } };
+                const filteredBizBot = additionalNodes?.find(n => n.tag === 'bot');
+                if (filteredBizBot) {
+                    stanza.content.push(...additionalNodes);
+                    didPushAdditional = true;
+                } else {
+                    stanza.content.push(botNode);
+                }
+            }
+            if (!destinationJid.includes('newsletter') && buttonType && destinationJid !== 'status@broadcast') {
+                const contentArgs = getButtonArgs(messages);
+                const filteredNode = additionalNodes?.find(n => n.tag === contentArgs?.tag);
+                if (filteredNode) {
+                    didPushAdditional = true;
+                    stanza.content.push(...additionalNodes);
+                } else if (contentArgs) {
+                    if (Array.isArray(contentArgs)) stanza.content.push(...contentArgs);
+                    else stanza.content.push(contentArgs);
+                }
+            }
+            if (!didPushAdditional && additionalNodes && additionalNodes.length > 0) {
+                stanza.content.push(...additionalNodes);
+            }
+            await sendNode(stanza);
+            if (messageRetryManager && !participant) {
+                messageRetryManager.addRecentMessage(destinationJid, msgId, message);
+            }
+        }, meId);
+        return msgId;
+    };
+
+    const sendRich = async (remoteJid, parts = [], quoted = null, extraCapabilities = []) => {
+        const rich = _buildRichResponse(parts, remoteJid);
+        const payload = proto.Message.fromObject({
+            botForwardedMessage: { message: { richResponseMessage: rich } },
+            messageContextInfo: { messageSecret: randomBytes(32), botMetadata: _buildBotMetadata(['RICH_RESPONSE_CODE', ...extraCapabilities]) }
+        });
+        const options = quoted ? { quoted: JSON.parse(JSON.stringify(quoted)) } : {};
+        const waMsg = generateWAMessageFromContent(remoteJid, payload, options);
+        return relayMessage(remoteJid, waMsg.message, { messageId: waMsg.key.id });
+    };
+
+    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({
+            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');
+    const hzxx = new Hzxx(Utils, waUploadToServer, relayMessage);
+    
+    const sendRichReels = async (jid, title, headerText, query, reels, options = {}) => {
+        const unified = {
+            response_id: `reels-${Date.now()}`,
+            sections: [
+                { view_model: { primitive: { text: title, __typename: "GenAIMarkdownTextUXPrimitive" }, __typename: "GenAISingleLayoutViewModel" } },
+                {
+                    view_model: {
+                        primitives: reels.map(reel => ({
+                            reels_url: reel.videoUrl,
+                            thumbnail_url: reel.thumbnailUrl,
+                            creator: reel.author,
+                            avatar_url: reel.profileIconUrl,
+                            reels_title: reel.title,
+                            likes_count: reel.likes || 0,
+                            shares_count: 0,
+                            view_count: 0,
+                            reel_source: reel.source || "WEB",
+                            is_verified: true,
+                            __typename: "GenAIReelPrimitive"
+                        })),
+                        __typename: "GenAIHScrollLayoutViewModel"
+                    }
+                }
+            ]
+        };
+
+        const rawMessage = {
+            botForwardedMessage: {
+                message: {
+                    richResponseMessage: {
+                        messageType: 1,
+                        submessages: [
+                            { messageType: 2, messageText: headerText },
+                            {
+                                messageType: 9, 
+                                contentItemsMetadata: {
+                                    contentType: 1, 
+                                    itemsMetadata: reels.map(r => ({ reelItem: { title: r.title, profileIconUrl: r.profileIconUrl, thumbnailUrl: r.thumbnailUrl, videoUrl: r.videoUrl } }))
+                                }
+                            }
+                        ],
+                        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)).toString("base64") },
+                        contextInfo: options.quoted ? {
+                            isForwarded: true,
+                            forwardingScore: 1,
+                            forwardOrigin: 4,
+                            forwardedAiBotMessageInfo: { botName: "Meta AI", botJid: "867051314767696@bot", creatorName: "Meta" },
+                            botMessageSharingInfo: { botEntryPointOrigin: String(jid).endsWith('@g.us') ? 30 : 29, forwardScore: 1 },
+                            stanzaId: options.quoted.key.id,
+                            participant: options.quoted.sender || options.quoted.key?.participant,
+                            quotedMessage: options.quoted.message
+                        } : {}
+                    }
+                }
+            },
+            messageContextInfo: {
+                messageSecret: randomBytes(32),
+                botMetadata: {
+                    modelMetadata: { modelType: "LLAMA_PROD", premiumModelStatus: "AVAILABLE" },
+                    botResponseId: `reels-${Date.now()}`,
+                    richResponseSourcesMetadata: {
+                        sources: reels.map((r, i) => ({
+                            provider: r.source || "WEB",
+                            thumbnailCDNURL: r.thumbnailUrl,
+                            sourceProviderURL: r.videoUrl,
+                            sourceQuery: query,
+                            faviconCDNURL: r.profileIconUrl,
+                            citationNumber: i + 1,
+                            sourceTitle: r.title
+                        }))
+                    },
+                    capabilityMetadata: { capabilities: ["RICH_RESPONSE_STRUCTURED_RESPONSE", "RICH_RESPONSE_UNIFIED_RESPONSE", "RICH_RESPONSE_UNIFIED_TEXT_COMPONENT", "RICH_RESPONSE_REELS", "SESSION_TRANSPARENCY_SYSTEM_MESSAGE"] }
+                }
+            }
+        };
+
+        const msgId = generateMessageIDV2(sock.user?.id);
+        return await relayMessage(jid, rawMessage, { messageId: msgId });
+    };
+
+    return {
+        ...sock,
+        getPrivacyTokens,
+        assertSessions,
+        relayMessage,
+        sendReceipt,
+        sendReceipts,
+        readMessages,
+        refreshMediaConn,
+        waUploadToServer,
+        fetchPrivacySettings,
+        sendPeerDataOperationMessage,
+        createParticipantNodes,
+        getUSyncDevices,
+        messageRetryManager,
+        hzxx,
+        sendRich,
+        makeText,
+        makeCode,
+        makeList,
+        makeTable,
+        sendRichReels,
+        normalizeSystem,
+        sendRichText: async (remoteJid, text, quoted = null) => sendRich(remoteJid, [makeText(text)], quoted),
+        sendRichCode: async (remoteJid, title, language, code, quoted = null) => {
+            const parts = [];
+            if (title) parts.push(makeText(title));
+            parts.push(makeCode(language, code));
+            return sendRich(remoteJid, parts, quoted, ['RICH_RESPONSE_CODE']);
+        },
+        sendRichList: async (remoteJid, title, items = [], quoted = null) => {
+            const parts = [];
+            if (title) parts.push(makeText(title));
+            parts.push(makeList(items));
+            return sendRich(remoteJid, parts, quoted);
+        },
+        sendRichTable: async (remoteJid, title, rows = [], footer = '', quoted = null) => {
+            const parts = [];
+            if (title) parts.push(makeText(title));
+            parts.push(makeTable(rows));
+            if (footer) parts.push(makeText(footer));
+            return sendRich(remoteJid, parts, quoted, ['RICH_RESPONSE_TABLE']);
+        },
+        sendRichFull: async (remoteJid, { title, language, code, items, table, footer } = {}, quoted = null) => {
+            const parts = [];
+            const caps = [];
+            if (title) parts.push(makeText(title));
+            if (code) { parts.push(makeCode(language || 'text', code)); caps.push('RICH_RESPONSE_CODE'); }
+            if (items?.length) parts.push(makeList(items));
+            if (table?.length) { parts.push(makeTable(table)); caps.push('RICH_RESPONSE_TABLE'); }
+            if (footer) parts.push(makeText(footer));
+            return sendRich(remoteJid, parts, quoted, caps);
+        },
+        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);
+            let error = undefined;
+            await Promise.all([
+                sendNode(node),
+                waitForMsgMediaUpdate(async (update) => {
+                    const result = update.find(c => c.key.id === message.key.id);
+                    if (result) {
+                        if (result.error) {
+                            error = result.error;
+                        } else {
+                            try {
+                                const media = await 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})`, {
+                                        data: media,
+                                        statusCode: getStatusCodeForMediaRetry(media.result) || 404
+                                    });
+                                }
+                                content.directPath = media.directPath;
+                                content.url = getUrlFromDirectPath(content.directPath);
+                                logger.debug({ directPath: media.directPath, key: result.key }, 'media update successful');
+                            } catch (err) {
+                                error = err;
+                            }
+                        }
+                        return true;
+                    }
+                })
+            ]);
+            if (error) throw error;
+            ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
+            return message;
+        },
+
+        sendMessage: async (jid, content, options = {}) => {
+            // Smart Router Roteamento Nativo LID / JID
+            const cleanTarget = normalizeSystem.cleanId(jid);
+            const mappedLid = normalizeSystem.jidLidMemoryCache.get(cleanTarget);
+            if (mappedLid) {
+                const signalId = signalRepository.jidToSignalProtocolAddress(mappedLid);
+                const hasLidSession = peerSessionsCache.get(signalId) || (await signalRepository.validateSession(mappedLid)).exists;
+                if (cleanTarget.includes('@s.whatsapp.net') && hasLidSession) {
+                    jid = mappedLid;
+                } else if (cleanTarget.includes('@lid') && !hasLidSession) {
+                    const mappedPn = normalizeSystem.jidLidMemoryCache.get(cleanTarget);
+                    if (mappedPn) jid = mappedPn;
+                }
+            }
+
+            const userJid = authState.creds.me.id;
+            const { filter = false, quoted } = options;
+            const getParticipantAttr = () => filter ? { participant: { jid } } : {};
+            if (content && content.interactiveButtons) {
+                const formattedButtons = content.interactiveButtons.map(btn => {
+                    if (btn.name === 'payment_info' || btn.name === 'review_and_pay') {
+                        try {
+                            const params = JSON.parse(btn.buttonParamsJson);
+                            params.currency = params.currency || 'BRL';
+                            params.total_amount = params.total_amount || { value: 0, offset: 100 };
+                            params.reference_id = params.reference_id || randomBytes(4).toString('hex').toUpperCase();
+                            params.type = params.type || 'physical-goods';
+                            if (!params.order) {
+                                params.order = {
+                                    status: 'pending',
+                                    subtotal: params.total_amount,
+                                    order_type: 'ORDER',
+                                    items: [{
+                                        name: 'Fatura via Pix', 
+                                        amount: params.total_amount,
+                                        quantity: 1,
+                                        sale_amount: params.total_amount
+                                    }]
+                                };
+                            }
+                            
+                            btn.buttonParamsJson = JSON.stringify(params);
+                        } catch (e) {
+                            logger.error({ err: e }, "[System Baileys] Erro ao processar JSON de Pagamento Nativo");
+                        }
+                    }
+                    return btn;
+                });
+                
+                const rawMessage = {
+                    messageContextInfo: { messageSecret: randomBytes(32) },
+                    interactiveMessage: {
+                        nativeFlowMessage: { buttons: formattedButtons },
+                        contextInfo: options.quoted ? {
+                            stanzaId: options.quoted.key.id,
+                            participant: options.quoted.sender || options.quoted.key?.participant,
+                            quotedMessage: options.quoted.message
+                        } : {}
+                    }
+                };
+                
+                if (content.text) {
+                    rawMessage.interactiveMessage.body = { text: content.text };
+                }
+
+                const msgId = generateMessageIDV2(sock.user?.id);
+                return await relayMessage(jid, rawMessage, { messageId: msgId, ...getParticipantAttr() });
+            }
+
+            if (typeof hzxx.buildMessageContent === 'function') {
+                content = await hzxx.buildMessageContent(content);
+            }
+            const messageType = hzxx.detectType(content);
+            
+            if (messageType) {
+                switch(messageType) {
+                    case 'PAYMENT':
+                        const paymentContent = await hzxx.handlePayment(content, quoted);
+                        return await relayMessage(jid, paymentContent, { messageId: generateMessageIDV2(), ...getParticipantAttr() });
+                    case 'PRODUCT':
+                        const productContent = await hzxx.handleProduct(content, jid, quoted);
+                        const productMsg = generateWAMessageFromContent(jid, productContent, { ...options, quoted });
+                        return await relayMessage(jid, productMsg.message, { messageId: productMsg.key.id, ...getParticipantAttr() });
+                    case 'INTERACTIVE':
+                        const interactiveContent = await hzxx.handleInteractive(content, jid, quoted);
+                        const interactiveMsg = generateWAMessageFromContent(jid, interactiveContent, { ...options, quoted });
+                        
+                        if (!interactiveMsg.message.messageContextInfo) {
+                            interactiveMsg.message.messageContextInfo = {};
+                        }
+                        interactiveMsg.message.messageContextInfo.deviceListMetadata = {};
+                        interactiveMsg.message.messageContextInfo.deviceListMetadataVersion = 2;
+
+                        return await relayMessage(jid, interactiveMsg.message, { messageId: interactiveMsg.key.id, ...getParticipantAttr() });
+                    case 'ALBUM':
+                        return await hzxx.handleAlbum(content, jid, quoted);
+                    case 'EVENT':
+                        return await hzxx.handleEvent(content, jid, quoted);
+                    case 'POLL_RESULT':
+                        return await hzxx.handlePollResult(content, jid, quoted);
+                    case 'GROUP_STORY':
+                        return await hzxx.handleGroupStory(content, jid, quoted);
+                }
+            }
+            if (typeof content === 'object' &&
+                'disappearingMessagesInChat' in content &&
+                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
+                isJidGroup(jid)) {
+                const { disappearingMessagesInChat } = content;
+                const value = typeof disappearingMessagesInChat === 'boolean'
+                    ? disappearingMessagesInChat
+                        ? WA_DEFAULT_EPHEMERAL
+                        : 0
+                    : disappearingMessagesInChat;
+                await groupToggleEphemeral(jid, value);
+            }
+            else {
+                const fullMsg = await generateWAMessage(jid, content, {
+                    logger,
+                    userJid,
+                    getUrlInfo: text => getUrlInfo(text, {
+                        thumbnailWidth: linkPreviewImageThumbnailWidth,
+                        fetchOpts: {
+                            timeout: 3000,
+                            ...(httpRequestOptions || {})
+                        },
+                        logger,
+                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                    }),
+                    getProfilePicUrl: sock.profilePictureUrl,
+                    getCallLink: sock.createCallLink,
+                    upload: waUploadToServer,
+                    mediaCache: config.mediaCache,
+                    options: config.options,
+                    messageId: generateMessageIDV2(sock.user?.id),
+                    ...options
+                });
+                const isEventMsg = 'event' in content && !!content.event;
+                const isDeleteMsg = 'delete' in content && !!content.delete;
+                const isEditMsg = 'edit' in content && !!content.edit;
+                const isPinMsg = 'pin' in content && !!content.pin;
+                const isPollMessage = 'poll' in content && !!content.poll;
+                
+                const isAiMsg = 'ai' in content && !!content.ai;
+
+                const additionalAttributes = {};
+                const additionalNodes = [];
+                if (isDeleteMsg) {
+                    if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
+                        additionalAttributes.edit = '8';
+                    } else {
+                        additionalAttributes.edit = '7';
+                    }
+                } else if (isEditMsg) {
+                    additionalAttributes.edit = '1';
+                } else if (isPinMsg) {
+                    additionalAttributes.edit = '2';
+                } else if (isPollMessage) {
+                    additionalNodes.push({ tag: 'meta', attrs: { polltype: 'creation' } });
+                } else if (isEventMsg) {
+                    additionalNodes.push({ tag: 'meta', attrs: { event_type: 'creation' } });
+                }
+
+                if (isAiMsg) {
+                    additionalNodes.push({ tag: 'bot', attrs: { biz_bot: '1' } });
+                }
+
+                await relayMessage(jid, fullMsg.message, {
+                    messageId: fullMsg.key.id,
+                    useCachedGroupMetadata: options.useCachedGroupMetadata,
+                    additionalAttributes,
+                    statusJidList: options.statusJidList,
+                    additionalNodes
+                });
+                if (config.emitOwnEvents) {
+                    process.nextTick(async () => {
+                        await processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
+        }
+    };
+};
+//# sourceMappingURL=messages-send.js.map