@neykoor/baileys 7.0.5-rc15 → 7.0.8-rc15

package/lib/Socket/messages-send.js

@@ -3,7 +3,7 @@ import { Boom } from '@neykoor/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, captureUnifiedResponse, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateCodeBlockContent, generateLatexContent, generateListContent, generateMessageIDV2, generateParticipantHashV2, generateRichMessageContent, generateTableContent, generateUnifiedResponseContent, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, compressMedia, convertMedia, captureUnifiedResponse, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateCodeBlockContent, generateLatexContent, generateLatexImageContent, generateLatexInlineImageContent, generateListContent, generateMessageIDV2, generateParticipantHashV2, generateRichMessageContent, generateTableContent, generateUnifiedResponseContent, generateWAMessage, generateWAMessageFromContent, getMediaMetadata, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, imageToWebpSticker, MessageRetryManager, MessageScheduler, normalizeMessageContent, parseAndInjectE2ESessions, resizeImage, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
@@ -11,30 +11,22 @@ import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, res
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET, STORIES_JID } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+import { Smgss } from './smgss.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
     const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
-    /**
-     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
-     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
-     * Entries are always removed in `.finally()`, so the set is bounded by concurrency.
-     */
     const inFlightTcTokenIssuance = new Set();
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
             useClones: false
         });
-    /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
     const devicesMutex = makeMutex();
-    // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
-    // Prevent race conditions in Signal session encryption by user
     const encryptionMutex = makeKeyedMutex();
     let mediaConn;
-    /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
     let mediaHost = DEF_MEDIA_HOST;
     const refreshMediaConn = async (forceGet = false) => {
         const media = await mediaConn;
@@ -50,7 +42,6 @@ export const makeMessagesSocket = (config) => {
                     content: [{ tag: 'media_conn', attrs: {} }]
                 });
                 const mediaConnNode = getBinaryNodeChild(result, 'media_conn');
-                // TODO: explore full length of data that whatsapp provides
                 const node = {
                     hosts: getBinaryNodeChildren(mediaConnNode, 'host').map(({ attrs }) => ({
                         hostname: attrs.hostname,
@@ -69,10 +60,6 @@ export const makeMessagesSocket = (config) => {
         }
         return mediaConn;
     };
-    /**
-     * generic send receipt function
-     * used for receipts of phone call, read, delivery etc.
-     * */
     const sendReceipt = async (jid, participant, messageIds, type) => {
         if (!messageIds || messageIds.length === 0) {
             throw new Boom('missing ids in receipt');
@@ -116,21 +103,17 @@ export const makeMessagesSocket = (config) => {
         logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages');
         await sendNode(node);
     };
-    /** Correctly bulk send receipts to multiple chats, participants */
     const sendReceipts = async (keys, type) => {
         const recps = aggregateMessageKeysNotFromMe(keys);
         for (const { jid, participant, messageIds } of recps) {
             await sendReceipt(jid, participant, messageIds, type);
         }
     };
-    /** Bulk read messages. Keys can be from different chats & participants */
     const readMessages = async (keys) => {
         const privacySettings = await fetchPrivacySettings();
-        // based on privacy settings, we have to change the read type
         const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self';
         await sendReceipts(keys, readType);
     };
-    /** Fetch all the devices we've to send a message to */
     const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
         const deviceResults = [];
         if (!useCache) {
@@ -193,16 +176,14 @@ export const makeMessagesSocket = (config) => {
         }
         const query = new USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol();
         for (const jid of toFetch) {
-            query.withUser(new USyncUser().withId(jid)); // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
+            query.withUser(new USyncUser().withId(jid));
         }
         const result = await sock.executeUSyncQuery(query);
         if (result) {
-            // TODO: LID MAP this stuff (lid protocol will now return lid with devices)
             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 })));
-                // Force-refresh sessions for newly mapped LIDs to align identity addressing
                 try {
                     const lids = lidResults.map(a => a.lid);
                     if (lids.length) {
@@ -219,10 +200,8 @@ export const makeMessagesSocket = (config) => {
                 deviceMap[item.user] = deviceMap[item.user] || [];
                 deviceMap[item.user]?.push(item);
             }
-            // Process each user's devices as a group for bulk LID migration
             for (const [user, userDevices] of Object.entries(deviceMap)) {
                 const isLidUser = requestedLidUsers.has(user);
-                // Process all devices for this user
                 for (const item of userDevices) {
                     const finalJid = isLidUser
                         ? jidEncode(user, item.server, item.device)
@@ -241,7 +220,6 @@ export const makeMessagesSocket = (config) => {
             }
             await devicesMutex.mutex(async () => {
                 if (userDevicesCache.mset) {
-                    // if the cache supports mset, we can set all devices in one go
                     await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
                 }
                 else {
@@ -269,9 +247,6 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
-    /**
-     * Update Member Label
-     */
     const updateMemberLabel = (jid, memberLabel) => {
         return relayMessage(jid, {
             protocolMessage: {
@@ -309,7 +284,6 @@ export const makeMessagesSocket = (config) => {
             jidsRequiringFetch.push(jid);
         }
         if (jidsRequiringFetch.length) {
-            // LID if mapped, otherwise original
             const wireJids = [
                 ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
                 ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
@@ -341,7 +315,6 @@ export const makeMessagesSocket = (config) => {
         return didFetchNewSession;
     };
     const sendPeerDataOperationMessage = async (pdoMessage) => {
-        //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
         if (!authState.creds.me?.id) {
             throw new Boom('Not authenticated');
         }
@@ -494,25 +467,23 @@ export const makeMessagesSocket = (config) => {
                 return;
             }
             if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
-                extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
+                extraAttrs['decrypt-fail'] = 'hide';
             }
             if (isGroupOrStatus && !isRetryResend) {
                 const [groupData, senderKeyMap] = await Promise.all([
                     (async () => {
-                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined; // todo: should we rely on the cache specially if the cache is outdated and the metadata has new fields?
+                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
                         if (groupData && Array.isArray(groupData?.participants)) {
                             logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata');
                         }
                         else if (!isStatus) {
-                            groupData = await groupMetadata(jid); // TODO: start storing group participant list + addr mode in Signal & stop relying on this
+                            groupData = await groupMetadata(jid);
                         }
                         return groupData;
                     })(),
                     (async () => {
                         if (!participant && !isStatus) {
-                            // what if sender memory is less accurate than the cached metadata
-                            // on participant change in group, we should do sender memory manipulation
-                            const result = await authState.keys.get('sender-key-memory', [jid]); // TODO: check out what if the sender key memory doesn't include the LID stuff now?
+                            const result = await authState.keys.get('sender-key-memory', [jid]);
                             return result[jid] || {};
                         }
                         return {};
@@ -557,8 +528,6 @@ export const makeMessagesSocket = (config) => {
                         !isHostedLidUser(deviceJid) &&
                         !isHostedPnUser(deviceJid) &&
                         device.device !== 99) {
-                        //todo: revamp all this logic
-                        // the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
                         senderKeyRecipients.push(deviceJid);
                         senderKeyMap[deviceJid] = true;
                     }
@@ -585,8 +554,6 @@ export const makeMessagesSocket = (config) => {
                 await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
             }
             else {
-                // ADDRESSING CONSISTENCY: Match own identity to conversation context
-                // TODO: investigate if this is true
                 let ownId = meId;
                 if (isLid && meLid) {
                     ownId = meLid;
@@ -607,7 +574,7 @@ export const makeMessagesSocket = (config) => {
                     devices.push({
                         user,
                         device: 0,
-                        jid: jidEncode(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
+                        jid: jidEncode(user, targetUserServer, 0)
                     });
                     if (user !== ownUser) {
                         const ownUserServer = isLid ? 'lid' : 's.whatsapp.net';
@@ -619,13 +586,10 @@ export const makeMessagesSocket = (config) => {
                         });
                     }
                     if (additionalAttributes?.['category'] !== 'peer') {
-                        // Clear placeholders and enumerate actual devices
                         devices.length = 0;
-                        // Use conversation-appropriate sender identity
                         const senderIdentity = isLid && meLid
                             ? 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);
                         devices.push(...sessionDevices);
                         logger.debug({
@@ -645,7 +609,6 @@ export const makeMessagesSocket = (config) => {
                         logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)');
                         continue;
                     }
-                    // Check if this is our device (could match either PN or LID user)
                     const isMe = user === mePnUser || user === meLidUser;
                     if (isMe) {
                         meRecipients.push(jid);
@@ -657,7 +620,6 @@ export const makeMessagesSocket = (config) => {
                 }
                 await assertSessions(allRecipients);
                 const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
-                    // For own devices: use DSM if available (1:1 chats only)
                     createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
                     createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
                 ]);
@@ -725,7 +687,7 @@ export const makeMessagesSocket = (config) => {
                 if (additionalAttributes?.['category'] === 'peer') {
                     const peerNode = participants[0]?.content?.[0];
                     if (peerNode) {
-                        binaryNodeContent.push(peerNode); // push only enc
+                        binaryNodeContent.push(peerNode);
                     }
                 }
                 else {
@@ -746,9 +708,6 @@ export const makeMessagesSocket = (config) => {
                 },
                 content: binaryNodeContent
             };
-            // if the participant to send to is explicitly specified (generally retry recp)
-            // ensure the message is only sent to that person
-            // if a retry receipt is sent to everyone -- it'll fail decryption for everyone else who received the msg
             if (participant) {
                 if (isJidGroup(destinationJid)) {
                     stanza.attrs.to = destinationJid;
@@ -797,19 +756,15 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
             const isPeerMessage = additionalAttributes?.['category'] === 'peer';
             const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
-            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
             const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
             const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
             const existingTokenEntry = contactTcTokenData[tcTokenJid];
             let tcTokenBuffer = existingTokenEntry?.token;
-            // Treat expired tokens the same as missing — clear from cache
             if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
                 logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
                 tcTokenBuffer = undefined;
-                // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
                 const cleared = existingTokenEntry?.senderTimestamp !== undefined
                     ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.senderTimestamp }
                     : null;
@@ -834,8 +789,6 @@ export const makeMessagesSocket = (config) => {
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
-            // Fire-and-forget: issue our token to the contact AFTER message send.
-            // WA Web skips protocol messages and PSA/bot contacts (TcTokenChatAction: isRegularUser)
             const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage;
             const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
             if (is1on1Send &&
@@ -876,7 +829,6 @@ export const makeMessagesSocket = (config) => {
                     inFlightTcTokenIssuance.delete(tcTokenJid);
                 });
             }
-            // Add message to retry cache if enabled
             if (messageRetryManager && !participant) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
             }
@@ -938,12 +890,18 @@ export const makeMessagesSocket = (config) => {
         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';
         }
@@ -976,6 +934,83 @@ export const makeMessagesSocket = (config) => {
         return result;
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
+    const smgss = new Smgss(waUploadToServer, relayMessage, config, sock);
+    const getButtonType = (message) => {
+        if (message.listMessage)
+            return 'list';
+        if (message.buttonsMessage)
+            return 'buttons';
+        if (message.templateMessage)
+            return 'template';
+        if (message.interactiveMessage?.nativeFlowMessage)
+            return 'native_flow';
+        if (message.interactiveMessage?.shopStorefrontMessage)
+            return 'shop';
+        if (message.interactiveMessage?.collectionMessage)
+            return 'collection';
+        if (message.interactiveMessage?.carouselMessage)
+            return 'carousel';
+        if (message.interactiveMessage)
+            return 'interactive';
+        return null;
+    };
+    const getButtonArgs = (message) => {
+        const nativeFlow = message.interactiveMessage?.nativeFlowMessage;
+        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'
+        ];
+        const ts = unixTimestampSeconds().toString();
+        const bizBase = { actual_actors: '2', host_storage: '2', privacy_mode_ts: ts };
+        const qualityControl = { tag: 'quality_control', attrs: { source_type: 'third_party' } };
+        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 (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
+            return {
+                tag: 'biz',
+                attrs: bizBase,
+                content: [
+                    {
+                        tag: 'interactive',
+                        attrs: { type: 'native_flow', v: '1' },
+                        content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+                    },
+                    qualityControl
+                ]
+            };
+        }
+        else if (nativeFlow || message.buttonsMessage || message.templateMessage || message.interactiveMessage) {
+            return {
+                tag: 'biz',
+                attrs: bizBase,
+                content: [
+                    {
+                        tag: 'interactive',
+                        attrs: { type: 'native_flow', v: '1' },
+                        content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+                    },
+                    qualityControl
+                ]
+            };
+        }
+        else if (message.listMessage) {
+            return {
+                tag: 'biz',
+                attrs: bizBase,
+                content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }, qualityControl]
+            };
+        }
+        return { tag: 'biz', attrs: bizBase };
+    };
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
     registerSocketEndHandler(() => {
         if (!config.userDevicesCache && userDevicesCache.close) {
@@ -1101,7 +1136,7 @@ export const makeMessagesSocket = (config) => {
         }
         return msg;
     };
-    return {
+    const messagesSock = {
         ...sock,
         userDevicesCache,
         devicesMutex,
@@ -1113,7 +1148,11 @@ export const makeMessagesSocket = (config) => {
         sendReceipts,
         readMessages,
         refreshMediaConn,
-        // Function (not getter) so the spread in chats.ts preserves the live closure binding.
+        resize: resizeImage,
+        convert: convertMedia,
+        toSticker: imageToWebpSticker,
+        compress: compressMedia,
+        metadata: getMediaMetadata,
         getMediaHost: () => mediaHost,
         waUploadToServer,
         fetchPrivacySettings,
@@ -1185,6 +1224,16 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, message, { messageId });
             return { message, messageId };
         },
+        sendLatexImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
+            const { message, messageId } = await generateLatexImageContent(quoted, options, uploadFn, renderLatexToPng);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
+        sendLatexInlineImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
+            const { message, messageId } = await generateLatexInlineImageContent(quoted, options, uploadFn, renderLatexToPng);
+            await relayMessage(jid, message, { messageId });
+            return { message, messageId };
+        },
         sendUnifiedResponse: async (jid, quoted, captured) => {
             const { message, messageId } = generateUnifiedResponseContent(quoted, captured);
             await relayMessage(jid, message, { messageId });
@@ -1197,6 +1246,15 @@ export const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            const smgssType = smgss.detectType(content);
+            if (smgssType) {
+                const quoted = options?.quoted;
+                const built = await smgss.handle(smgssType, content, jid, quoted);
+                if (smgssType === 'ALBUM' || smgssType === 'EVENT' || smgssType === 'POLL_RESULT' || smgssType === 'GROUP_STORY') {
+                    return built;
+                }
+                content = built;
+            }
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -1222,7 +1280,6 @@ export const makeMessagesSocket = (config) => {
                         logger,
                         uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
                     }),
-                    //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
                     getCallLink: sock.createCallLink,
                     upload: waUploadToServer,
@@ -1232,17 +1289,16 @@ export const makeMessagesSocket = (config) => {
                     ...options
                 });
                 const isEventMsg = 'event' in content && !!content.event;
-                const isDeleteMsg = 'delete' in content && !!content.delete;
+                const deleteKey = 'delete' in content ? content.delete : undefined;
+                const isDeleteMsg = !!deleteKey;
                 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 = [];
-                // required for delete
                 if (isDeleteMsg) {
-                    // if the chat is a group, and I am not the author, then delete the message as an admin
-                    if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
+                    if (isJidGroup(deleteKey?.remoteJid) && !deleteKey?.fromMe) {
                         additionalAttributes.edit = '8';
                     }
                     else {
@@ -1289,6 +1345,12 @@ export const makeMessagesSocket = (config) => {
                     });
                     delete content.ai;
                 }
+                const buttonType = getButtonType(fullMsg.message);
+                if (buttonType) {
+                    const btnNode = getButtonArgs(fullMsg.message);
+                    if (btnNode)
+                        additionalNodes.push(btnNode);
+                }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
@@ -1305,5 +1367,17 @@ export const makeMessagesSocket = (config) => {
             }
         }
     };
+    const messageScheduler = new MessageScheduler(messagesSock.sendMessage, {
+        logger: config.logger
+    });
+    return {
+        ...messagesSock,
+        messageScheduler,
+        scheduleMessage: messageScheduler.schedule.bind(messageScheduler),
+        scheduleMessageDelay: messageScheduler.scheduleDelay.bind(messageScheduler),
+        cancelScheduledMessage: messageScheduler.cancel.bind(messageScheduler),
+        cancelScheduledMessagesForJid: messageScheduler.cancelForJid.bind(messageScheduler),
+        getPendingScheduledMessages: messageScheduler.getPending.bind(messageScheduler)
+    };
 };
 //# sourceMappingURL=messages-send.js.map