@pontalabs/baileys 1.2.4 → 1.2.5

package/lib/Socket/messages-send.js

@@ -14,7 +14,7 @@ import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
 import kikyy from './dugong.js';
 import { generateTableContent, generateTableContentV2, generateListContent, generateCodeBlockContent, generateCodeBlockContentV2, generateLinkContent, generateLinkContentV2, generateRichMessageContent, generateUnifiedResponseContent, captureUnifiedResponse, generateLatexContent, generateLatexImageContent, generateLatexInlineImageContent } from '../Utils/rich-message-utils.js';
-import { Button, ButtonV2, Carousel } from '../Utils/mbuilder.js';
+import { AIRich, Button, ButtonV2, Carousel } from '../Utils/mbuilder.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
@@ -1134,67 +1134,155 @@ export const makeMessagesSocket = (config) => {
             const userJid = authState.creds.me.id;
 
             // `items` may contain Rich AI build descriptors as well as the
-            // interactive builders exported by mbuilder.js. Rich AI items can
-            // stay grouped when no delay is requested; interactive builders
-            // are always sent as their own native-flow message because they
-            // are not valid Rich AI primitives.
+            // interactive builders exported by mbuilder.js. When buildDelay is
+            // enabled, keep ONE WhatsApp message id and progressively edit that
+            // message instead of sending a new bubble for every item.
             if (content && !Array.isArray(jid) && Array.isArray(content.items) && content.items.length > 0) {
                 const items = content.items;
                 const buildDelay = Number(options.buildDelay ?? content.buildDelay ?? 0);
                 const hasDelay = Number.isFinite(buildDelay) && buildDelay > 0;
                 const isInteractiveBuilder = (item) => item instanceof Button || item instanceof ButtonV2 || item instanceof Carousel;
+                const isAIRichBuilder = (item) => item instanceof AIRich;
                 const hasInteractiveBuilder = items.some(isInteractiveBuilder);
 
                 if (hasDelay || hasInteractiveBuilder) {
                     const sendOptions = { ...options };
                     delete sendOptions.buildDelay;
                     delete sendOptions.additionalNodes;
-                    const results = [];
 
-                    const sendInteractiveBuilder = async (builder) => {
-                        // Builder instances are intentionally socket-less when
-                        // created through build.button()/buttonV2()/carousel().
-                        // Bind only the upload capability needed while building
-                        // media; the actual send still uses this socket's
-                        // relayMessage path, exactly like the native sendMessage
-                        // implementation.
-                        builder.setClient({ waUploadToServer });
-                        const msg = await builder.build(jid, sendOptions);
-                        await relayMessage(msg.key.remoteJid, msg.message, {
-                            messageId: msg.key.id,
-                            additionalNodes: [
-                                {
-                                    tag: 'biz',
-                                    attrs: {},
-                                    content: [
-                                        {
-                                            tag: 'interactive',
-                                            attrs: { type: 'native_flow', v: '1' },
-                                            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
-                                        },
-                                    ],
-                                },
-                                ...(options.additionalNodes || []),
-                            ],
+                    // One target id for the entire progressive sequence. If the
+                    // caller supplied messageId, it is used; otherwise the first
+                    // generated message id becomes the target for all edits.
+                    let targetMessageId = options.messageId;
+                    let lastMessage;
+
+                    const buildItemMessage = async (item) => {
+                        if (isInteractiveBuilder(item)) {
+                            item.setClient({ waUploadToServer });
+                            return await item.build(jid, { ...sendOptions, messageId: targetMessageId });
+                        }
+
+                        if (isAIRichBuilder(item)) {
+                            return await item.build(jid, { ...sendOptions, messageId: targetMessageId });
+                        }
+
+                        // Send Rich AI descriptors through the normal Rich AI
+                        // generator, but force the same message id.
+                        return await generateWAMessage(jid, { items: [item] }, {
+                            logger,
+                            userJid,
+                            upload: waUploadToServer,
+                            mediaCache: config.mediaCache,
+                            options: config.options,
                             ...sendOptions,
+                            messageId: targetMessageId || generateMessageIDV2(userJid)
+                        });
+                    };
+
+                    const isRichAiMessage = (msg) => !!(
+                        msg?.message?.botForwardedMessage?.message?.richResponseMessage ||
+                        msg?.message?.richResponseMessage
+                    );
+
+                    const relayEdit = async (msg, targetId) => {
+                        const editedMessage = msg.message;
+                        const editMessage = await generateWAMessageFromContent(jid, {
+                            botForwardedMessage: { message: { protocolMessage: {
+                                key: { remoteJid: jid, fromMe: true, id: targetId },
+                                type: 14,
+                                editedMessage
+                            } } }
+                        }, { messageId: generateMessageIDV2(userJid) });
+
+                        await relayMessage(jid, editMessage.message, {
+                            messageId: editMessage.key.id,
+                            additionalNodes: options.additionalNodes || []
                         });
-                        return msg;
+                        return editMessage;
                     };
 
+                    // Build a cumulative snapshot on every step. This is the
+                    // important part of buildDelay: each edit contains everything
+                    // built so far, rather than replacing the previous message
+                    // with only the newest item.
+                    const cumulativeItems = [];
+
                     for (let index = 0; index < items.length; index++) {
-                        if (index > 0 && hasDelay) await delay(buildDelay);
+                        if (index > 0 && hasDelay) {
+                            await delay(buildDelay);
+                        }
 
-                        const item = items[index];
-                        if (isInteractiveBuilder(item)) {
-                            results.push(await sendInteractiveBuilder(item));
+                        cumulativeItems.push(items[index]);
+
+                        // AIRich instances represent an already assembled rich
+                        // response. For these, use their own build() directly.
+                        // For ordinary descriptors we rebuild the cumulative set.
+                        let msg;
+                        if (cumulativeItems.length === 1 && isAIRichBuilder(cumulativeItems[0])) {
+                            msg = await buildItemMessage(cumulativeItems[0]);
+                        } else if (cumulativeItems.every(isInteractiveBuilder) && cumulativeItems.length === 1) {
+                            msg = await buildItemMessage(cumulativeItems[0]);
+                        } else {
+                            const hasAirich = cumulativeItems.some(isAIRichBuilder);
+                            if (hasAirich) {
+                                // Mixed AIRich + descriptor items are flattened by
+                                // taking the AIRich message as the current snapshot
+                                // and are intentionally not sent as media.
+                                const ai = cumulativeItems.find(isAIRichBuilder);
+                                msg = await ai.build(jid, { ...sendOptions, messageId: targetMessageId });
+                            } else {
+                                msg = await generateWAMessage(jid, { items: cumulativeItems }, {
+                                    logger,
+                                    userJid,
+                                    upload: waUploadToServer,
+                                    mediaCache: config.mediaCache,
+                                    options: config.options,
+                                    ...sendOptions,
+                                    messageId: targetMessageId || generateMessageIDV2(userJid)
+                                });
+                            }
+                        }
+
+                        if (!targetMessageId) {
+                            targetMessageId = msg.key.id;
+                        }
+
+                        if (index === 0) {
+                            const additionalNodes = isInteractiveBuilder(items[index])
+                                ? [
+                                    {
+                                        tag: 'biz',
+                                        attrs: {},
+                                        content: [{
+                                            tag: 'interactive',
+                                            attrs: { type: 'native_flow', v: '1' },
+                                            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+                                        }],
+                                    },
+                                    ...(options.additionalNodes || []),
+                                ]
+                                : (options.additionalNodes || []);
+
+                            await relayMessage(jid, msg.message, {
+                                messageId: targetMessageId,
+                                additionalNodes,
+                                ...sendOptions,
+                            });
+
+                            if (isRichAiMessage(msg) && options.bypassDownload !== false) {
+                                await relayEdit(msg, targetMessageId);
+                            }
                         } else {
-                            // Keep the same Rich AI normalization path used by
-                            // the regular shortcut, preventing build descriptors
-                            // from reaching prepareWAMessageMedia().
-                            results.push(await sendMessageImpl(jid, { items: [item] }, sendOptions));
+                            await relayEdit(msg, targetMessageId);
                         }
+
+                        lastMessage = msg;
+                    }
+
+                    if (lastMessage) {
+                        lastMessage.key.id = targetMessageId;
                     }
-                    return results;
+                    return lastMessage;
                 }
             }
             // Update rahmi's userJid in case it changed after login

package/lib/Utils/rich-message-utils.js

@@ -826,6 +826,34 @@ const normalizeTableInput = (t, fallbackTitle, fallbackNoHeading) => {
     return { rows: [], title: fallbackTitle, noHeading: fallbackNoHeading };
 };
 
+/** Buat unified section untuk RICH CARD / ENTITY */
+const makeRichCardSection = (data) => {
+    const item = data || {};
+    const thumbnailUrl = item.thumbnail_url ?? item.thumbnailUrl ?? item.thumbnail ?? '';
+    const profileUrl = item.profile_url ?? item.profileUrl ?? thumbnailUrl;
+
+    return {
+        view_model: {
+            primitive: {
+                __typename: 'GenAICompactEntityPrimitive',
+                title: item.title ?? '',
+                subtitle: item.subtitle ?? '',
+                secondary_subtitle: item.description ?? '',
+                entity_id: item.entity_id ?? item.entityId ?? '',
+                entity_url: item.entity_url ?? item.entityUrl ?? '',
+                entity_type: item.entity_type ?? 'PAGE',
+                action_type: item.action_type ?? 'FOLLOW',
+                is_verified: !!item.verification,
+                image: {
+                    url: thumbnailUrl,
+                    url_fallback: profileUrl
+                }
+            },
+            __typename: 'GenAISingleLayoutViewModel'
+        }
+    };
+};
+
 /* ─────────────────────────────────────────────────────────────
    MAIN BUILDER — prepareRichResponseMessage
 ───────────────────────────────────────────────────────────── */
@@ -839,7 +867,7 @@ export const prepareRichResponseMessage = (content) => {
         map: mapContent, latex, contentItems,
         // sub-types baru (prefixed 'rich' agar tidak konflik dengan media biasa)
         richImage, richVideo, reels, source, richProduct, richPost, tip, suggest,
-        richWidget, widget, richFooterAction, footerAction, richMetadata, metadata, richFOAText, foaText, richHtml,
+        richWidget, widget, richFooterAction, footerAction, richMetadata, metadata, richFOAText, foaText, richHtml, richCard,
         // opsi tambahan (belum ada di versi ponta.zip semula)
         aiForwarded
     } = content;
@@ -928,6 +956,7 @@ export const prepareRichResponseMessage = (content) => {
         if (sub.footerAction != null) return push(null, makeFooterActionSection(sub.footerAction));
         if (sub.metadata != null) { const built = makeMetadataSub(sub.metadata); return push(built.sub, built.section); }
         if (sub.foaText != null) { const built = makeMetadataSub(sub.foaText, 'FOATextPrimitive'); return push(built.sub, built.section); }
+        if (sub.richCard != null) return push(null, makeRichCardSection(sub.richCard));
         if (sub.richHtml != null) return push(null, makeHtmlSection(sub.richHtml));
         // passthrough — kalau sudah bentuk proto submessage manual
         return push(sub, buildUnifiedSection(sub));
@@ -1538,6 +1567,7 @@ const translateReadmeItem = (item) => {
     if (item.richText != null) { out.text = item.richText; }
     if (item.richFOAText != null) { out.foaText = item.richFOAText; }
     if (item.richHtml != null) { out.richHtml = item.richHtml; }
+    if (item.richCard != null) { out.richCard = item.richCard; }
     if (item.richCode != null) { out.code = item.richCode; out.language = item.language; }
     if (item.richTable != null) { out.table = item.richTable; }
     if (item.richSource != null) { out.source = item.richSource; }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pontalabs/baileys",
   "type": "module",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "PontaLabs Baileys is a lightweight, modern, and customizable WhatsApp Web API library built on Baileys.",
   "keywords": [
     "whatsapp",