@kelvdra/baileys 1.0.4 → 1.0.5-rc.2

package/lib/Socket/messages-send.js

@@ -2,17 +2,20 @@ 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, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import * as Utils_1 from "../Utils/index.js"
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, 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 * as WABinary_1 from "../WABinary/index.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 hydra from './hydra.js'
+import { randomBytes } from "crypto"
 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 { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -255,31 +258,6 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
-    /**
-     * Update Member Label
-     */
-    const updateMemberLabel = (jid, memberLabel) => {
-        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
@@ -376,59 +354,57 @@ export const makeMessagesSocket = (config) => {
             ? patched
             : recipientJids.map(jid => ({ recipientJid: jid, message: patched }));
         let shouldIncludeDeviceIdentity = false;
-        const meId = authState.creds.me.id;
+        const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
         const meLidUser = meLid ? jidDecode(meLid)?.user : null;
         const encryptionPromises = patchedMessages.map(async ({ recipientJid: jid, message: patchedMessage }) => {
-            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
-                            }
-                        ]
-                    };
-                });
-                return node;
-            }
-            catch (err) {
-                logger.error({ jid, err }, 'Failed to encrypt for recipient');
+            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
+                        }
+                    ]
+                };
+            });
+            return node;
         });
         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 meId = authState.creds.me.id;
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList } = {}) => {
+        const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
         const isRetryResend = Boolean(participant?.jid);
         let shouldIncludeDeviceIdentity = isRetryResend;
@@ -441,13 +417,19 @@ export const makeMessagesSocket = (config) => {
         const isGroupOrStatus = isGroup || isStatus;
         const finalJid = jid;
         msgId = msgId || generateMessageIDV2(meId);
-        useUserDevicesCache = useUserDevicesCache !== false;
-        useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
+        // Anti waiting-message fix: default to fresh device/group lookup.
+        // Stale device cache/sender-key metadata can make recipient clients show
+        // "menunggu pesan" until a retry happens. Existing callers can still
+        // opt in to cache with useUserDevicesCache: true / useCachedGroupMetadata: true.
+        useUserDevicesCache = useUserDevicesCache === true;
+        useCachedGroupMetadata = useCachedGroupMetadata === true && !isStatus;
         const participants = [];
+        let additionalAlready = false
         const destinationJid = !isStatus ? finalJid : statusJid;
         const binaryNodeContent = [];
         const devices = [];
-        let reportingMessage;
+        const messages = Utils_1.normalizeMessageContent(message)
+        const buttonType = getButtonType(messages)
         const meMsg = {
             deviceSentMessage: {
                 destinationJid,
@@ -542,7 +524,6 @@ 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({
@@ -597,12 +578,6 @@ 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({
@@ -627,7 +602,7 @@ export const makeMessagesSocket = (config) => {
                             ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined)
                             : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined);
                         // Enumerate devices for sender and target with consistent addressing
-                        const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false);
+                        const sessionDevices = await getUSyncDevices([senderIdentity, jid], !!useUserDevicesCache, false);
                         devices.push(...sessionDevices);
                         logger.debug({
                             deviceCount: devices.length,
@@ -738,6 +713,16 @@ export const makeMessagesSocket = (config) => {
             else {
                 stanza.attrs.to = destinationJid;
             }
+            if (!isNewsletter && buttonType) {
+                const buttonsNode = getButtonArgs(messages)
+                const filteredButtons = WABinary_1.getBinaryFilteredButtons(additionalNodes ? additionalNodes : [])
+                if (filteredButtons) {
+                    stanza.content.push(...additionalNodes)
+                    additionalAlready = true
+                } else {
+                    stanza.content.push(buttonsNode)
+                }
+            }
             if (shouldIncludeDeviceIdentity) {
                 ;
                 stanza.content.push({
@@ -747,29 +732,6 @@ export const makeMessagesSocket = (config) => {
                 });
                 logger.debug({ jid }, 'adding device identity');
             }
-            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');
-                }
-            }
             const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
             const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
             if (tcTokenBuffer) {
@@ -780,7 +742,7 @@ export const makeMessagesSocket = (config) => {
                     content: tcTokenBuffer
                 });
             }
-            if (additionalNodes && additionalNodes.length > 0) {
+            if (!additionalAlready && additionalNodes && additionalNodes.length > 0) {
                 ;
                 stanza.content.push(...additionalNodes);
             }
@@ -794,9 +756,26 @@ export const makeMessagesSocket = (config) => {
         return msgId;
     };
     const getMessageType = (message) => {
-        if (message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3) {
+        // Keep group status wrappers as text stanza like 1.0.4.
+        // If this wrapper is normalized first, inner image/video content can be
+        // detected as media and status-group relay may fail on WA clients.
+        if (message?.groupStatusMessageV2 || message?.groupStatusMessage) {
+            return 'text';
+        }
+        // stickerPackMessage/media must be sent as media, especially in groups.
+        const normalizedMessage = Utils_1.normalizeMessageContent(message) || message;
+        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) => {
@@ -824,6 +803,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker_pack';
+        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -847,6 +829,114 @@ export const makeMessagesSocket = (config) => {
         }
         return '';
     };
+    
+    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'
+        }
+    }
+
+    const getButtonArgs = (message) => {
+        const message_content = message.viewOnceMessage?.message || message;
+        const message_flow = message_content.interactiveMessage?.nativeFlowMessage;
+        const flow_buttons_first = message_flow?.buttons?.[0]?.name;
+        const flow_buttons_special = [ 'mpm', 'cta_catalog', 'send_location', 'call_permission_request', 'wa_payment_transaction_details', 'automated_greeting_message_view_catalog' ];
+        const baseArgs = {
+            tag: 'biz',
+            attrs: {
+                actual_actors: '2',
+                host_storage: '2',
+                privacy_mode_ts: Utils_1.unixTimestampSeconds().toString()
+            }
+        };
+        if (message_flow && (flow_buttons_first === 'review_and_pay' || flow_buttons_first === 'payment_info')) {
+            return {
+                tag: 'biz',
+                attrs: {
+                    native_flow_name: flow_buttons_first === 'review_and_pay' ? 'order_details' : flow_buttons_first
+                }
+            };
+        }
+        if (message_flow && flow_buttons_special.includes(flow_buttons_first)) {
+            return {
+                ...baseArgs,
+                content: [
+                    {
+                        tag: 'interactive',
+                        attrs: { type: 'native_flow', v: '1' },
+                        content: [{
+                            tag: 'native_flow',
+                            attrs: { v: '2', name: flow_buttons_first }
+                        }]
+                    },
+                    {
+                        tag: 'quality_control',
+                        attrs: { source_type: 'third_party' }
+                    }
+                ]
+            };
+        }
+        if (message_flow || message_content.buttonsMessage) {
+            return {
+                ...baseArgs,
+                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' }
+                    }
+                ]
+            };
+        }
+        if (message_content.listMessage) {
+            return {
+                ...baseArgs,
+                content: [
+                    {
+                        tag: 'list',
+                        attrs: { v: '2', type: 'product_list' }
+                    },
+                    {
+                        tag: 'quality_control',
+                        attrs: { source_type: 'third_party' }
+                    }
+                ]
+            };
+        }
+        return baseArgs;
+    };
+    
     const getPrivacyTokens = async (jids) => {
         const t = unixTimestampSeconds().toString();
         const result = await query({
@@ -873,7 +963,22 @@ export const makeMessagesSocket = (config) => {
         });
         return result;
     };
+    
+    const getEphemeralGroup = (jid) => {
+        if (!WABinary_1.isJidGroup(jid)) throw new TypeError("Jid should originate from a group!")
+
+        return groupQuery(jid, 'get', [{
+                tag: 'query',
+                attrs: {
+                    request: 'interactive'
+                }
+            }])
+            .then((groups) => WABinary_1.getBinaryNodeChild(groups, 'group'))
+            .then((metadata) => WABinary_1.getBinaryNodeChild(metadata, 'ephemeral')?.attrs?.expiration || 0)
+    }
+    
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
+    const kelvdra = new hydra(Utils_1, waUploadToServer, relayMessage)
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
     return {
         ...sock,
@@ -885,17 +990,17 @@ export const makeMessagesSocket = (config) => {
         readMessages,
         refreshMediaConn,
         waUploadToServer,
+        kelvdra,
         fetchPrivacySettings,
         sendPeerDataOperationMessage,
         createParticipantNodes,
         getUSyncDevices,
         messageRetryManager,
-        updateMemberLabel,
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message);
             const mediaKey = content.mediaKey;
-            const meId = authState.creds.me.id;
-            const node = encryptMediaRetryRequest(message.key, mediaKey, meId);
+            const meId = assertMeId(authState.creds);
+            const node = await encryptMediaRetryRequest(message.key, mediaKey, meId);
             let error = undefined;
             await Promise.all([
                 sendNode(node),
@@ -907,7 +1012,7 @@ export const makeMessagesSocket = (config) => {
                         }
                         else {
                             try {
-                                const media = decryptMediaRetryData(result.media, mediaKey, result.key.id);
+                                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})`, {
@@ -933,8 +1038,316 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
+        sendStatusMentions: async (content, jids = []) => {
+            const userJid = WABinary_1.jidNormalizedUser(authState.creds.me.id)
+            let allUsers = new Set()
+            allUsers.add(userJid)
+
+            for (const id of jids) {
+                const isGroup = WABinary_1.isJidGroup(id)
+                const isPrivate = WABinary_1.isPnUser(id)
+
+                if (isGroup) {
+                    try {
+                        const metadata = await cachedGroupMetadata(id) || await global.groupMetadataCache(id)
+                        const participants = metadata.participants.map(p => WABinary_1.jidNormalizedUser(p.id))
+                        participants.forEach(jid => allUsers.add(jid))
+                    } catch (error) {
+                        logger.error(`Error getting metadata for group ${id}: ${error}`)
+                    }
+                } else if (isPrivate) {
+                    allUsers.add(WABinary_1.jidNormalizedUser(id))
+                }
+            }
+
+            const uniqueUsers = Array.from(allUsers)
+            const getRandomHexColor = () => "#" + Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0")
+
+            const isMedia = content.image || content.video || content.audio
+            const isAudio = !!content.audio
+
+            const messageContent = {
+                ...content
+            }
+
+            if (isMedia && !isAudio) {
+                if (messageContent.text) {
+                    messageContent.caption = messageContent.text
+
+                    delete messageContent.text
+                }
+
+                delete messageContent.ptt
+                delete messageContent.font
+                delete messageContent.backgroundColor
+                delete messageContent.textColor
+            }
+
+            if (isAudio) {
+                delete messageContent.text
+                delete messageContent.caption
+                delete messageContent.font
+                delete messageContent.textColor
+            }
+
+            const font = !isMedia ? (content.font || Math.floor(Math.random() * 9)) : undefined
+            const textColor = !isMedia ? (content.textColor || getRandomHexColor()) : undefined
+            const backgroundColor = (!isMedia || isAudio) ? (content.backgroundColor || getRandomHexColor()) : undefined
+            const ptt = isAudio ? (typeof content.ptt === 'boolean' ? content.ptt : true) : undefined
+
+            let msg
+            let mediaHandle
+            try {
+                msg = await Utils_1.generateWAMessage(WABinary_1.STORIES_JID, messageContent, {
+                    logger,
+                    userJid,
+                    getUrlInfo: text => link_preview_1.getUrlInfo(text, {
+                        thumbnailWidth: linkPreviewImageThumbnailWidth,
+                        fetchOpts: {
+                            timeout: 3000,
+                            ...axiosOptions || {}
+                        },
+                        logger,
+                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                    }),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, {
+                            ...opts
+                        })
+                        mediaHandle = up.handle
+                        return up
+                    },
+                    mediaCache: config.mediaCache,
+                    options: config.options,
+                    font,
+                    textColor,
+                    backgroundColor,
+                    ptt
+                })
+            } catch (error) {
+                logger.error(`Error generating message: ${error}`)
+                throw error
+            }
+
+            await relayMessage(WABinary_1.STORIES_JID, msg.message, {
+                messageId: msg.key.id,
+                statusJidList: uniqueUsers,
+                additionalNodes: [{
+                    tag: 'meta',
+                    attrs: {},
+                    content: [{
+                        tag: 'mentioned_users',
+                        attrs: {},
+                        content: jids.map(jid => ({
+                            tag: 'to',
+                            attrs: {
+                                jid: WABinary_1.jidNormalizedUser(jid)
+                            }
+                        }))
+                    }]
+                }]
+            })
+
+            for (const id of jids) {
+                try {
+                    const normalizedId = WABinary_1.jidNormalizedUser(id)
+                    const isPrivate = WABinary_1.isJidUser(normalizedId)
+                    const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage'
+
+                    const protocolMessage = {
+                        [type]: {
+                            message: {
+                                protocolMessage: {
+                                    key: msg.key,
+                                    type: 25
+                                }
+                            }
+                        },
+                        messageContextInfo: {
+                            messageSecret: randomBytes(32)
+                        }
+                    }
+
+                    const statusMsg = await Utils_1.generateWAMessageFromContent(normalizedId,
+                        protocolMessage, {}
+                    )
+
+                    await relayMessage(
+                        normalizedId,
+                        statusMsg.message, {
+                            additionalNodes: [{
+                                tag: 'meta',
+                                attrs: isPrivate ? {
+                                    is_status_mention: 'true'
+                                } : {
+                                    is_group_status_mention: 'true'
+                                }
+                            }]
+                        }
+                    )
+
+                    await Utils_1.delay(2000)
+                } catch (error) {
+                    logger.error(`Error sending to ${id}: ${error}`)
+                }
+            }
+
+            return msg
+        },
+        sendAlbumMessage: async (jid, medias, options = {}) => {
+            const userJid = authState.creds.me.id
+            for (const media of medias) {
+                if (!media.image && !media.video) throw new TypeError(`medias[i] must have image or video property`)
+            }
+            if (medias.length < 2) throw new RangeError("Minimum 2 media")
+            const time = options.delay || 500
+            delete options.delay
+            const album = await Utils_1.generateWAMessageFromContent(jid, {
+                albumMessage: {
+                    expectedImageCount: medias.filter(media => media.image).length,
+                    expectedVideoCount: medias.filter(media => media.video).length,
+                    ...options
+                }
+            }, {
+                userJid,
+                ...options
+            })
+            await relayMessage(jid, album.message, {
+                messageId: album.key.id
+            })
+            let mediaHandle
+            let msg
+            for (const i in medias) {
+                const media = medias[i]
+                if (media.image) {
+                    msg = await Utils_1.generateWAMessage(jid, {
+                        image: media.image,
+                        ...media,
+                        ...options
+                    }, {
+                        userJid,
+                        upload: async (readStream, opts) => {
+                            const up = await waUploadToServer(readStream, {
+                                ...opts,
+                                newsletter: WABinary_1.isJidNewsletter(jid)
+                            })
+                            mediaHandle = up.handle
+                            return up
+                        },
+                        ...options
+                    })
+                } else if (media.video) {
+                    msg = await Utils_1.generateWAMessage(jid, {
+                        video: media.video,
+                        ...media,
+                        ...options
+                    }, {
+                        userJid,
+                        upload: async (readStream, opts) => {
+                            const up = await waUploadToServer(readStream, {
+                                ...opts,
+                                newsletter: WABinary_1.isJidNewsletter(jid)
+                            })
+                            mediaHandle = up.handle
+                            return up
+                        },
+                        ...options,
+                    })
+                }
+                if (msg) {
+                    msg.message.messageContextInfo = {
+                        messageSecret: randomBytes(32),
+                        messageAssociation: {
+                            associationType: 1,
+                            parentMessageKey: album.key
+                        }
+                    }
+                }
+                await relayMessage(jid, msg.message, {
+                    messageId: msg.key.id
+                })
+                await Utils_1.delay(time)
+            }
+            return album
+        },
+        sendAIRich: async (jid, content = {}, options = {}) => {
+            const { quoted, filter = false } = options;
+            const getParticipantAttr = () => filter ? { participant: { jid } } : {};
+            return await kelvdra.handleAIRich({ aiRich: content }, jid, quoted, {
+                ...getParticipantAttr()
+            });
+        },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            const normalizeDeleteKey = async (key = {}) => {
+                const normalized = { ...key };
+                const resolveLid = async (value) => {
+                    if (!value || !isLidUser(value)) return value;
+                    try {
+                        return (await signalRepository?.lidMapping?.getPNForLID(value)) || value;
+                    } catch {
+                        return value;
+                    }
+                };
+                normalized.remoteJid = await resolveLid(normalized.remoteJid || jid);
+                normalized.participant = await resolveLid(normalized.participant);
+                if (isJidGroup(normalized.remoteJid || jid) && !normalized.participant) {
+                    normalized.participant = normalized.fromMe ? userJid : undefined;
+                }
+                return normalized;
+            };
+            if (content?.delete) {
+                content = { ...content, delete: await normalizeDeleteKey(content.delete) };
+            }
+            const additionalAttributes = {}
+            const { filter = false, quoted } = options;
+            const getParticipantAttr = () => filter ? { participant: { jid } } : {};
+            const messageType = kelvdra.detectType(content);
+
+            if (messageType) {
+                switch (messageType) {
+        case 'PAYMENT':
+            const paymentContent = await kelvdra.handlePayment(content, quoted);
+            return await relayMessage(jid, paymentContent, {
+                messageId: Utils_1.generateMessageID(),
+                ...getParticipantAttr()
+            });
+
+        case 'PRODUCT':
+            const productContent = await kelvdra.handleProduct(content, jid, quoted);
+            const productMsg = await Utils_1.generateWAMessageFromContent(jid, productContent, { quoted });
+            return await relayMessage(jid, productMsg.message, {
+                messageId: productMsg.key.id,
+                ...getParticipantAttr()
+            });
+
+        case 'INTERACTIVE':
+            const interactiveContent = await kelvdra.handleInteractive(content, jid, quoted);
+            const interactiveMsg = await Utils_1.generateWAMessageFromContent(jid, interactiveContent, { quoted });
+            return await relayMessage(jid, interactiveMsg.message, {
+                messageId: interactiveMsg.key.id,
+                ...getParticipantAttr()
+            });
+
+        case 'ALBUM':
+            const albumContent = await kelvdra.handleAlbum(content, jid, quoted);
+            return albumContent;
+
+        case 'EVENT':
+            return await kelvdra.handleEvent(content, jid, quoted);
+
+        case 'POLL_RESULT':
+            return await kelvdra.handlePollResult(content, jid, quoted);
+
+        case 'CAROUSEL':
+            return await kelvdra.handleCarousel(content, jid, quoted);
+                        
+        case 'AI_RICH':
+            return await kelvdra.handleAIRich(content, jid, quoted, {
+                ...getParticipantAttr()
+            });
+    }
+}
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -1017,7 +1430,7 @@ export const makeMessagesSocket = (config) => {
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
-                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                        await processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
                 return fullMsg;