plogme 2.0.2 → 2.0.4

package/lib/Socket/messages-send.js

@@ -3,9 +3,9 @@ import { Boom } from '@hapi/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, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { prepareRichMenuMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareHtmlMessage, prepareRichHtmlMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
+import { prepareRichMenuMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
 import { generateMiniAppHtml } from '../Utils/games/miniapp.js';
 import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/games/website-preview.js';
@@ -1033,6 +1033,53 @@ export const makeMessagesSocket = (config) => {
         return msgId;
     };
 
+    /**
+     * Relay a rich envelope and then replay it as a type-14 edit. Some
+     * WhatsApp clients otherwise show a Download prompt before rendering the
+     * AIRich unifiedResponse. The edit is only applied to bot-forwarded rich
+     * envelopes, so ordinary messages are never duplicated accidentally.
+     * Set renderRichResponse: false for callers that explicitly do not want
+     * the compatibility replay.
+     */
+    const relayRichMessage = async (jid, fullMsg, options = {}) => {
+        const relayOptions = {
+            messageId: fullMsg.key.id,
+            useCachedGroupMetadata: options.useCachedGroupMetadata,
+            statusJidList: options.statusJidList,
+            ...options.relayOptions,
+        };
+        await relayMessage(jid, fullMsg.message, relayOptions);
+
+        const richEnvelope = fullMsg.message?.botForwardedMessage?.message?.richResponseMessage;
+        if (options.renderRichResponse !== false && richEnvelope) {
+            const editContent = proto.Message.fromObject({
+                botForwardedMessage: {
+                    message: {
+                        protocolMessage: {
+                            key: {
+                                remoteJid: jid,
+                                fromMe: true,
+                                id: fullMsg.key.id,
+                            },
+                            type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+                            editedMessage: fullMsg.message,
+                        },
+                    },
+                },
+            });
+            const editMessage = generateWAMessageFromContent(jid, editContent, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: generateMessageIDV2(authState.creds.me?.id || jid),
+            });
+            await relayMessage(jid, editMessage.message, {
+                ...relayOptions,
+                messageId: editMessage.key.id,
+            });
+        }
+        return fullMsg;
+    };
+
     const getMessageType = (message) => {
         if (!message)
             return 'text';
@@ -1229,18 +1276,39 @@ export const makeMessagesSocket = (config) => {
         },
         sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
             const { message, messageId } = generateTableContent(title, headers, rows, quoted, options);
-            await relayMessage(jid, message, { messageId });
-            return { message, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || messageId || generateMessageIDV2(jid),
+                quoted,
+                ...options
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
         },
         sendList: async (jid, title, items, quoted, options = {}) => {
             const { message, messageId } = generateListContent(title, items, quoted, options);
-            await relayMessage(jid, message, { messageId });
-            return { message, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || messageId || generateMessageIDV2(jid),
+                quoted,
+                ...options
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
         },
         sendCodeBlock: async (jid, code, quoted, options = {}) => {
             const { message, messageId } = generateCodeBlockContent(code, quoted, options);
-            await relayMessage(jid, message, { messageId });
-            return { message, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || messageId || generateMessageIDV2(jid),
+                quoted,
+                ...options
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
         },
         sendCarousel: async (jid, cards, options = {}) => {
             if (!Array.isArray(cards) || cards.length === 0) {
@@ -1276,8 +1344,15 @@ export const makeMessagesSocket = (config) => {
         },
         sendLatex: async (jid, quoted, options = {}) => {
             const { message, messageId } = generateLatexContent(quoted, { expressions: [], ...options });
-            await relayMessage(jid, message, { messageId });
-            return { message, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || messageId || generateMessageIDV2(jid),
+                quoted,
+                ...options
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
         },
         /**
          * Send LaTeX as rendered PNG image (like Meta AI does).
@@ -1305,8 +1380,14 @@ export const makeMessagesSocket = (config) => {
                 headerText,
                 footer
             });
-            await relayMessage(jid, message, { messageId });
-            return { message, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || messageId || generateMessageIDV2(jid),
+                ...options
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
         },
         sendMetaAI: async (a, b, c = {}) => {
             // baron signature: (jid, text, opts) — README signature: (text, opts)
@@ -1391,11 +1472,7 @@ export const makeMessagesSocket = (config) => {
                 quoted,
                 ...options
             });
-            await relayMessage(jid, generated.message, {
-                messageId: generated.key.id,
-                useCachedGroupMetadata: options.useCachedGroupMetadata,
-                statusJidList: options.statusJidList
-            });
+            await relayRichMessage(jid, generated, options);
             return { ...generated, messageId: generated.key.id };
         },
         /**
@@ -1408,9 +1485,15 @@ export const makeMessagesSocket = (config) => {
                 responseId: options.responseId,
                 forwarded: options.forwarded !== false
             });
-            const messageId = generateMessageIDV2(jid);
-            await relayMessage(jid, generated.message, { messageId, quoted });
-            return { ...generated, messageId };
+            const fullMsg = generateWAMessageFromContent(jid, generated.message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || generated.messageId || generateMessageIDV2(jid),
+                quoted,
+                ...options,
+            });
+            await relayRichMessage(jid, fullMsg, options);
+            return { ...generated, messageId: fullMsg.key.id };
         },
         /**
          * Replace the generation primitive in an existing rich response.
@@ -1476,14 +1559,47 @@ export const makeMessagesSocket = (config) => {
                 quoted,
                 ...options
             });
-            await relayMessage(jid, fullMsg.message, {
-                messageId: fullMsg.key.id,
-                useCachedGroupMetadata: options.useCachedGroupMetadata,
-                statusJidList: options.statusJidList
+            await relayRichMessage(jid, fullMsg, options);
+            return fullMsg;
+        },
+        /**
+         * Send one tolerant AIRich/unified response containing every supported
+         * section present in `content`. Missing sections are intentionally
+         * ignored by prepareRichResponseMessage instead of causing a partial
+         * response to fail. This is the stable entry point for Plogme/CODY
+         * callers that may receive optional text, links, media, products,
+         * reels, tables, code, latex, or suggestion data.
+         */
+        sendPlogmeMessage: async (jid, content = {}, quoted, options = {}) => {
+            if (!jid) throw new Boom('sendPlogmeMessage requires a target JID', { statusCode: 400 });
+            if (!content || typeof content !== 'object' || Array.isArray(content)) {
+                throw new Boom('sendPlogmeMessage content must be an object', { statusCode: 400 });
+            }
+
+            const wrapped = prepareRichResponseMessage({
+                ...content,
+                // Avoid silently appending the library donation link to a
+                // unified response unless the caller explicitly opts in.
+                noDonation: options.noDonation ?? true,
             });
+            const fullMsg = generateWAMessageFromContent(jid, wrapped, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+                quoted,
+                ...options,
+            });
+
+            await relayRichMessage(jid, fullMsg, options);
+
+            if (config.emitOwnEvents) {
+                process.nextTick(async () => {
+                    await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                });
+            }
             return fullMsg;
         },
-        captureAndResendUnifiedResponse: async (jid, metaAiMsg, quoted) => {
+        captureAndResendUnifiedResponse: async (jid, metaAiMsg, quoted, options = {}) => {
             const captured = captureUnifiedResponse(metaAiMsg);
             if (!captured) {
                 throw new Boom('captureAndResendUnifiedResponse: message contains no unifiedResponse data');
@@ -1495,11 +1611,7 @@ export const makeMessagesSocket = (config) => {
                 messageId: generated.messageId || generateMessageIDV2(jid),
                 quoted
             });
-            await relayMessage(jid, fullMsg.message, {
-                messageId: fullMsg.key.id,
-                useCachedGroupMetadata: options?.useCachedGroupMetadata,
-                statusJidList: options?.statusJidList
-            });
+            await relayRichMessage(jid, fullMsg, options);
             return fullMsg;
         },
         updateMediaMessage: async (message) => {
@@ -2039,6 +2151,9 @@ export const makeMessagesSocket = (config) => {
             }
             // ── NORMAL MESSAGE HANDLING ──
             else {
+                if ('album' in content) {
+                    return socket.sendAlbumMessage(jid, content.album, options);
+                }
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,
                     userJid,
@@ -2127,13 +2242,6 @@ export const makeMessagesSocket = (config) => {
                     delete content.ai;
                 }
 
-                if ('album' in content) {
-                    if (!Array.isArray(content.album) || content.album.length < 2) {
-                        throw new Boom('Album requires at least two image or video items', { statusCode: 400 });
-                    }
-                    fullMsg.message.messageContextInfo ||= {};
-                    fullMsg.message.messageContextInfo.messageSecret ||= randomBytes(32);
-                }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
@@ -2150,55 +2258,6 @@ export const makeMessagesSocket = (config) => {
                     });
                 }
 
-                if ('album' in content) {
-                    const { delayMs = 1500 } = options;
-                    for (const [messageIndex, albumMedia] of content.album.entries()) {
-                        // Give the album collection stanza time to register before
-                        // its associated media children are relayed. This mirrors
-                        // the ordering used by WhatsApp clients and avoids the
-                        // children being treated as unrelated media messages.
-                        await delay(delayMs);
-                        const albumMsg = await generateWAMessage(jid, albumMedia, {
-                            logger,
-                            userJid,
-                            upload: waUploadToServer,
-                            mediaCache: config.mediaCache,
-                            options: config.options,
-                            ...options,
-                            messageId: generateMessageIDV2(userJid)
-                        });
-                        if (!hasValidAlbumMedia(normalizeMessageContent(albumMsg.message))) {
-                            throw new Boom('Invalid message type for album', { statusCode: 400 });
-                        }
-                        albumMsg.message.messageContextInfo ||= {};
-                        // WhatsApp expects an encrypted context secret on each album
-                        // child. Without it, clients may show the album as an
-                        // unsupported message or fail to group the media together.
-                        albumMsg.message.messageContextInfo.messageSecret ||= randomBytes(32);
-                        albumMsg.message.messageContextInfo.messageAssociation = {
-                            parentMessageKey: fullMsg.key,
-                            // WhatsApp album child messages use association type 1.
-                            // The generated MEDIA_ALBUM enum value (63) is a message
-                            // category, not the child-association wire value.
-                            associationType: 1,
-                            messageIndex
-                        };
-                        await relayMessage(jid, albumMsg.message, {
-                            messageId: albumMsg.key.id,
-                            useCachedGroupMetadata: options.useCachedGroupMetadata,
-                            addBizAttributes: isNeedBizAttrs,
-                            statusJidList: options.statusJidList,
-                            additionalAttributes,
-                            additionalNodes
-                        });
-                        if (config.emitOwnEvents) {
-                            process.nextTick(async () => {
-                                await messageMutex.mutex(() => upsertMessage(albumMsg, 'append'));
-                            });
-                        }
-                    }
-                }
-
                 return fullMsg;
             }
         }
@@ -2216,11 +2275,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList,
-        });
+        await relayRichMessage(jid, fullMsg, options);
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2241,11 +2296,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList,
-        });
+        await relayRichMessage(jid, fullMsg, options);
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2259,7 +2310,7 @@ export const makeMessagesSocket = (config) => {
         if (!content.copyText) throw new Boom('sendRichTextCopy requires copyText content', { statusCode: 400 });
         const wrapped = prepareRichQuoteMessage(content);
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /** Sends Markdown text containing blockquotes in a forwarded GenAI rich response. */
@@ -2267,7 +2318,7 @@ export const makeMessagesSocket = (config) => {
         if (!jid) throw new Boom('sendMarkdownQuote requires a target JID', { statusCode: 400 });
         const wrapped = prepareRichQuoteMessage(content);
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /** Sends Markdown blockquotes followed by a GenAI COPY_TO_CLIPBOARD action. */
@@ -2276,7 +2327,7 @@ export const makeMessagesSocket = (config) => {
         if (!content.copyText) throw new Boom('sendQuoteCopy requires copyText content', { statusCode: 400 });
         const wrapped = prepareRichQuoteMessage(content);
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /**
@@ -2291,11 +2342,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList,
-        });
+        await relayRichMessage(jid, fullMsg, options);
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2315,11 +2362,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList,
-        });
+        await relayRichMessage(jid, fullMsg, options);
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2336,11 +2379,53 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList,
+        await relayRichMessage(jid, fullMsg, options);
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+    /**
+     * Sends the A2UI interactive card/menu format used by WhatsApp's large
+     * command-card presentation. This is intentionally separate from richMenu
+     * because it is an interactiveMessage, not an AIRich unifiedResponse.
+     */
+    socket.sendA2UICommandMenu = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendA2UICommandMenu requires a target JID', { statusCode: 400 });
+        const { image, ...menuContent } = content || {};
+        let imageMessage;
+        if (image) {
+            const prepared = await prepareWAMessageMedia({ image }, { upload: waUploadToServer });
+            imageMessage = prepared.imageMessage;
+        }
+        const wrapped = prepareA2UICommandMenu({ ...menuContent, imageMessage });
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options,
         });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, ...options.relayOptions });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+    /** Sends the manually serialized AIRich command card shown in the screenshot. */
+    socket.sendAIRichCommandMenu = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendAIRichCommandMenu requires a target JID', { statusCode: 400 });
+        const wrapped = prepareAIRichCommandMenu(content);
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options,
+        });
+        await relayRichMessage(jid, fullMsg, options);
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2357,7 +2442,7 @@ export const makeMessagesSocket = (config) => {
             botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages: [{ messageType: 2, messageText: text }], contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4 } } } }
         };
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /** Sends a rich response with experimental BotCommandMetadata. */
@@ -2366,7 +2451,7 @@ export const makeMessagesSocket = (config) => {
         const { text = 'Bot command test', commandName = '', commandDescription = '', commandPrompt = '', botJid = '867051314767696@bot' } = content;
         const wrapped = buildBotRichResponse({ text, botJid, botMetadata: { commandMetadata: { commandName, commandDescription, commandPrompt } } });
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /** Sends a planning/execution-plan rich response with WAProto capabilities. */
@@ -2389,7 +2474,7 @@ export const makeMessagesSocket = (config) => {
             ]
         });
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     /** Sends a rich response with experimental BotResolvedToolCallMetadata. */
@@ -2408,7 +2493,7 @@ export const makeMessagesSocket = (config) => {
             }
         });
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
     socket.sendStatus = async (content, options = {}) => {
@@ -2611,25 +2696,73 @@ export const makeMessagesSocket = (config) => {
 
 
     /**
-     * Sends an experimental WhatsApp album. The parent album header and each
-     * image/video child are relayed separately and associated by parent key.
-     * Accepts [{ image: ... }, { video: ... }] or [{ type: 'image', data: ... }].
+     * Sends a full-width vertical AIRich album. Unlike the legacy
+     * albumMessage collection or compact GRID_IMAGE layout, this is one
+     * forwarded unified-response message with one large media item per row.
      */
     socket.sendAlbumMessage = async (jid, medias = [], options = {}) => {
         if (!jid) throw new Boom('sendAlbumMessage requires a target JID', { statusCode: 400 });
         if (!Array.isArray(medias) || medias.length < 2) {
             throw new Boom('sendAlbumMessage requires at least two media items', { statusCode: 400 });
         }
-        const album = medias.map((media, index) => {
-            const normalized = media?.type && media?.data
-                ? { [media.type]: media.data }
-                : { ...media };
-            if (index === 0 && options.caption && !normalized.caption) {
-                normalized.caption = options.caption;
+        const albumItems = medias.map((media) => {
+            const raw = media?.type && media?.data ? media.data : (media?.image ?? media);
+            if (media?.video || media?.type === 'video') {
+                const video = media?.video || raw;
+                const sourceUrl = typeof video === 'string' ? video : (video?.url || video?.videoUrl || '');
+                if (!sourceUrl) throw new Boom('Each video album item requires a video URL', { statusCode: 400 });
+                return { type: 'video', video: { ...video, url: sourceUrl } };
             }
-            return normalized;
+            return {
+                type: 'image',
+                image: raw
+            };
+        });
+        const wrapped = prepareVerticalAlbumMessage({
+            items: albumItems,
+            verificationMetadata: options.verificationMetadata
         });
-        return socket.sendMessage(jid, { album }, options);
+        const fullMsg = generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options
+        });
+        await relayRichMessage(jid, fullMsg, options);
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+
+    /**
+     * Sends a unified-response video grid. This uses GenAIVideoPrimitive items
+     * inside GenAIGridLayoutViewModel; it is not the image-only GRID_IMAGE type.
+     */
+    socket.sendVideoGridMessage = async (jid, videos = [], options = {}) => {
+        if (!jid) throw new Boom('sendVideoGridMessage requires a target JID', { statusCode: 400 });
+        if (!Array.isArray(videos) || videos.length < 2) {
+            throw new Boom('sendVideoGridMessage requires at least two videos', { statusCode: 400 });
+        }
+        const wrapped = prepareVideoGridMessage({
+            videos,
+            verificationMetadata: options.verificationMetadata
+        });
+        const fullMsg = generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options
+        });
+        await relayRichMessage(jid, fullMsg, options);
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
     };
 
 
@@ -2688,11 +2821,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id),
             ...options
         });
-        await relayMessage(jid, fullMsg.message, {
-            messageId: fullMsg.key.id,
-            useCachedGroupMetadata: options.useCachedGroupMetadata,
-            statusJidList: options.statusJidList
-        });
+        await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
 

package/lib/Utils/messages.js

@@ -1061,30 +1061,8 @@ export const generateWAMessageContent = async (message, options) => {
         };
         delete m.orderMessage.orderText;
     }
-    // Lia@Changes 31-01-26 --- Add support for album messages
     else if (hasNonNullishProperty(message, 'album')) {
-        if (!Array.isArray(message.album)) {
-            throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
-        }
-        let videoCount = 0;
-        for (let i = 0; i < message.album.length; i++) {
-            if (message.album[i].video)
-                videoCount++;
-        }
-        ;
-        let imageCount = 0;
-        for (let i = 0; i < message.album.length; i++) {
-            if (message.album[i].image)
-                imageCount++;
-        }
-        ;
-        if ((videoCount + imageCount) < 2) {
-            throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
-        }
-        m.albumMessage = {
-            expectedImageCount: imageCount,
-            expectedVideoCount: videoCount
-        };
+        throw new Boom('Legacy albumMessage is removed; use socket.sendAlbumMessage() for an AIRich GRID_IMAGE album', { statusCode: 400 });
     }
     else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
         m.protocolMessage = {