plogme 2.0.3 → 2.0.5

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

@@ -376,6 +376,110 @@ const richMenuButton = (button, toast = '') => {
  * This is an experimental WhatsApp rich-response format, not a standard
  * buttonsMessage/nativeFlowMessage payload.
  */
+/**
+ * Build a universal AIRich social/entity result card.
+ * The wire format is provider-neutral; Instagram is exposed as a dedicated
+ * convenience wrapper below because it is the primary supported profile view.
+ */
+export const prepareSocialEntityMessage = ({
+    username = '',
+    platform = 'GENERIC',
+    title = 'CODY AI',
+    subtitle = '⚉',
+    imageUrl = '',
+    entityId,
+    entityUrl = '',
+    entityType,
+    fullName = 'NOT found',
+    isVerified = false,
+    resultText = 'See results',
+    botJid = '867051314767696@bot',
+    responseId
+} = {}) => {
+    const normalizedPlatform = String(platform || 'GENERIC').toUpperCase();
+    const profileUrl = entityUrl || (username ? `https://www.${normalizedPlatform.toLowerCase()}.com/${encodeURIComponent(username)}` : '');
+    const resolvedType = entityType || (normalizedPlatform === 'INSTAGRAM' ? 'IG_PROFILE' : 'SOCIAL_PROFILE');
+    const displayName = username || fullName || 'Profile';
+    const sections = [
+        {
+            view_model: {
+                primitives: [{
+                    title,
+                    subtitle,
+                    ...(imageUrl ? { image: { url: imageUrl, mime_type: 'image/png' } } : {}),
+                    entity_id: String(entityId ?? username ?? ''),
+                    entity_url: profileUrl,
+                    entity_type: 'WEBSITE',
+                    action_type: 'OPEN_URL',
+                    is_verified: !!isVerified,
+                    __typename: 'GenAICompactEntityPrimitive'
+                }],
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        },
+        {
+            view_model: {
+                primitives: [{ type: 'HORIZONTAL_LINE', __typename: 'GenAIDividerPrimitive' }],
+                __typename: 'GenAIVStackLayoutViewModel'
+            }
+        },
+        {
+            view_model: {
+                primitives: [
+                    { __typename: 'GenAISpacerPrimitive' },
+                    {
+                        text: `# {{social_entity_1}}${resultText}\0{{/social_entity_1}}    `,
+                        inline_entities: [{
+                            key: 'social_entity_1',
+                            metadata: {
+                                __typename: 'GenAISocialEntityItem',
+                                entity_id: String(entityId ?? username ?? ''),
+                                entity_name: displayName,
+                                entity_full_name: fullName,
+                                entity_picture_url: imageUrl,
+                                entity_url: profileUrl,
+                                entity_type: resolvedType,
+                                platform: normalizedPlatform,
+                                is_verified: !!isVerified
+                            }
+                        }],
+                        __typename: 'GenAIMarkdownTextUXPrimitive'
+                    },
+                    { __typename: 'GenAISpacerPrimitive' }
+                ],
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        }
+    ];
+    return {
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: 1,
+                    submessages: [],
+                    unifiedResponse: {
+                        response_id: responseId || randomUUID(),
+                        data: Buffer.from(JSON.stringify({ sections })).toString('base64')
+                    },
+                    contextInfo: {
+                        isForwarded: true,
+                        forwardOrigin: 4,
+                        forwardedAiBotMessageInfo: { botJid }
+                    }
+                }
+            }
+        }
+    };
+};
+
+/** Dedicated Instagram profile card using the universal social-entity wire format. */
+export const prepareInstagramProfileMessage = (content = {}) => prepareSocialEntityMessage({
+    ...content,
+    platform: 'INSTAGRAM',
+    entityType: 'IG_PROFILE',
+    entityUrl: content.entityUrl || (content.username ? `https://www.instagram.com/${encodeURIComponent(content.username)}` : undefined)
+});
+
 export const prepareRichMenuMessage = (content = {}) => {
     const { header = {}, body = {}, footer = {}, verificationMetadata } = content || {};
     const sections = [];
@@ -472,6 +576,101 @@ export const prepareRichMenuMessage = (content = {}) => {
  * @param {'END'|'START'|'CENTER'} [options.alignment='END'] - Button alignment
  * @returns {Object} Wrapped botForwardedMessage ready for relayMessage
  */
+/** Build the manually serialized AIRich command menu shown in the screenshot. */
+export const prepareAIRichCommandMenu = ({ image, title = 'CODY AI', subtitle = '', code = '', rows = [], buttons = [], footer = 'Developed by - CODY AI', latexImage, latexExpression = '' } = {}) => {
+    if (!image) throw new Error('AIRich command menu requires an image URL');
+    if (!Array.isArray(rows)) throw new Error('AIRich command-menu rows must be an array');
+    if (!Array.isArray(buttons)) throw new Error('AIRich command-menu buttons must be an array');
+    const safeRows = rows.map((row, index) => ({ command: String(row?.[0] ?? row?.command ?? `command_${index + 1}`), description: String(row?.[1] ?? row?.description ?? '') }));
+    const table = ['Command | Function', '--- | ---', ...safeRows.map((row) => `${row.command} | ${row.description}`)].join('\n');
+    const inlineEntities = latexImage ? [{ key: 'NGA', metadata: { latex_expression: String(latexExpression), latex_image: { url: String(latexImage), width: 400, height: 400 }, font_height: 83.333, padding: 15, __typename: 'GenAILatexItem' } }] : [];
+    const text = [String(title), subtitle && String(subtitle), code && `Code: ${String(code)}`, '## Command List', table, footer && String(footer)].filter(Boolean).join('\n');
+    const imagePrimitive = { __typename: 'GenAIImagePrimitive', preview_image: { __typename: 'GenAIMediaItem', mime_type: 'image/png', url: String(image) }, full_image: { __typename: 'GenAIMediaItem', mime_type: 'image/png', url: String(image) } };
+    const ctas = buttons.map((button, index) => ({ label: String(button?.text || button?.label || `Button ${index + 1}`), state: 'PENDING', kind: 'OTHER', tool_call_id: String(button?.id || `airich_menu_${index + 1}`), toast: { label: String(button?.toast || ''), __typename: 'GenAIExtWidgetToast' }, __typename: 'GenAI3PExtWidgetCTA' }));
+    const footerPrimitives = buttons.map((button, index) => ({ cta_text: String(button?.text || button?.label || `Button ${index + 1}`), cta_type: 'OPEN_URL', cta_url: String(button?.url || ''), __typename: 'GenAIFooterActionPrimitive' }));
+    footerPrimitives.push({ cta_text: '☷ OPEN MENU', cta_type: 'OPEN_URL', cta_url: String(buttons[0]?.url || ''), __typename: 'GenAIFooterActionPrimitive' });
+    const sections = [
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { __typename: 'GenAISingleLayoutViewModel', primitive: imagePrimitive } },
+        ...(ctas.length ? [{ __typename: 'GenAIUnifiedResponseSection', view_model: { primitives: [{ __typename: 'GenAI3PExtWidgetPrimitive', header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: 'Command List' }, body: { __typename: 'GenAIExtCalendarEventList', ctas, sections: [] } }], __typename: 'GenAIActionRowLayoutViewModel' } }] : []),
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { primitive: { text: `{{NGA}}${text}{{/NGA}}`, inline_entities: inlineEntities, __typename: 'GenAIMarkdownTextUXPrimitive' }, __typename: 'GenAISingleLayoutViewModel' } },
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { primitives: footerPrimitives, __typename: 'GenAIActionRowLayoutViewModel' } }
+    ];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: text }],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: randomUUID(), sections })) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+/**
+ * Build an arbitrary A2UI interactive message. The command-menu helper below
+ * is only a convenience preset; callers may provide any supported component,
+ * widget, or native-flow payload through this universal builder.
+ */
+export const prepareA2UIMessage = ({ imageMessage, bloksWidget = {}, nativeFlowMessage, fallback = '', ...interactiveFields } = {}) => ({
+    interactiveMessage: {
+        ...interactiveFields,
+        ...(imageMessage ? { header: { imageMessage, hasMediaAttachment: true } } : {}),
+        bloksWidget: {
+            type: bloksWidget.type || 'im_a2ui',
+            data: typeof bloksWidget.data === 'string' ? bloksWidget.data : JSON.stringify(bloksWidget.data || {}),
+            ...(bloksWidget.fallback || fallback ? { fallback: String(bloksWidget.fallback || fallback) } : {})
+        },
+        ...(nativeFlowMessage ? {
+            nativeFlowMessage: {
+                ...nativeFlowMessage,
+                ...(nativeFlowMessage.buttons ? { buttons: nativeFlowMessage.buttons } : {})
+            }
+        } : {})
+    }
+});
+
+/** Build the A2UI interactive command menu used by the full-size card layout. */
+export const prepareA2UICommandMenu = ({ imageMessage, title = 'CODY AI', rows = [], buttons = [], fallback = '' } = {}) => {
+    if (!Array.isArray(rows)) throw new Error('A2UI command-menu rows must be an array');
+    if (!Array.isArray(buttons)) throw new Error('A2UI command-menu buttons must be an array');
+    const safeRows = rows.map((row, index) => ({
+        title: String(row?.[0] ?? row?.title ?? `Command ${index + 1}`),
+        description: String(row?.[1] ?? row?.description ?? ''),
+        id: String(row?.[2] ?? row?.id ?? row?.[0] ?? `command_${index + 1}`)
+    }));
+    const safeButtons = buttons.map((button, index) => ({ id: `a2ui_button_${index + 1}`, label: String(button?.text || button?.label || `Button ${index + 1}`), url: String(button?.url || '') }));
+    const componentIds = ['title', 'divider', 'tableCard', 'footer', ...(safeButtons.length ? ['buttonRow'] : [])];
+    const components = [
+        { id: 'root', component: 'Column', align: 'center', children: componentIds },
+        { id: 'title', component: 'Text', text: String(title), variant: 'h2' },
+        { id: 'divider', component: 'Divider' },
+        { id: 'tableCard', component: 'Card', child: 'tableColumn' },
+        { id: 'tableColumn', component: 'Column', children: ['headerRow', ...safeRows.flatMap((_, index) => [`divider_${index}`, `row_${index}`])] },
+        { id: 'headerRow', component: 'Row', children: ['headerCommand', 'headerFunction'] },
+        { id: 'headerCommand', component: 'Text', text: 'Command', variant: 'h5' },
+        { id: 'headerFunction', component: 'Text', text: 'Function', variant: 'h5' },
+        ...safeRows.flatMap((row, index) => [
+            { id: `divider_${index}`, component: 'Divider' },
+            { id: `row_${index}`, component: 'Row', children: [`command_${index}`, `description_${index}`] },
+            { id: `command_${index}`, component: 'Text', text: row.title },
+            { id: `description_${index}`, component: 'Text', text: row.description }
+        ]),
+        { id: 'footer', component: 'Text', text: 'Developed by - CODY AI', variant: 'caption' }
+    ];
+    if (safeButtons.length) {
+        components.push({ id: 'buttonRow', component: 'Row', justify: 'spaceEvenly', children: safeButtons.flatMap((button, index) => [`buttonLabel_${index}`, `button_${index}`]) });
+        safeButtons.forEach((button, index) => {
+            components.push({ id: `buttonLabel_${index}`, component: 'Text', text: button.label });
+            components.push({ id: `button_${index}`, component: 'Button', child: `buttonLabel_${index}`, variant: 'primary', action: { call: 'openUrl', args: { url: button.url } } });
+        });
+    }
+    return {
+        interactiveMessage: {
+            ...(imageMessage ? { header: { imageMessage, hasMediaAttachment: true } } : {}),
+            bloksWidget: { type: 'im_a2ui', data: JSON.stringify({ version: 'v0.9', createSurface: { surfaceId: 'plogme-a2ui-command-menu', catalogId: 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json', components } }), fallback: String(fallback || title) },
+            nativeFlowMessage: { messageParamsJson: JSON.stringify({ limited_time_offer: { text: String(title), url: safeButtons[0]?.url || '', copy_code: String(title), expiration_time: Date.now() * 1000 } }), buttons: [{ name: 'single_select', buttonParamsJson: JSON.stringify({ title: String(title), sections: [{ title: 'Available Commands', rows: safeRows }] }) }] }
+        }
+    };
+};
+
 export const prepareCopyToClipboardMessage = (options = {}) => {
     const { text = '', label, alignment = 'END', verificationMetadata } = options;
     const displayText = label || text;
@@ -697,9 +896,116 @@ export const prepareGridImageMessage = ({ imageUrls = [], verificationMetadata }
     return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
 };
 
+/**
+ * Build a video grid using the client-supported GenAIVideoPrimitive.
+ *
+ * WhatsApp exposes no AIRich GRID_VIDEO submessage type. Video grids therefore
+ * use the generic unified-response Grid layout with one GenAIVideoPrimitive per
+ * item. This is deliberately separate from prepareGridImageMessage so callers
+ * do not accidentally label video media as GenAIImagePrimitive.
+ */
+/** Build a full-width vertical album with one large media item per row. */
+export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata } = {}) => {
+    if (!Array.isArray(items) || items.length < 2) throw new Error('Vertical album requires at least two media items');
+    const expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    const primitives = items.map((item) => {
+        const kind = item?.type || (item?.video ? 'video' : 'image');
+        if (kind === 'video') {
+            const video = item.video || item.data || item;
+            const url = typeof video === 'string' ? video : (video?.url || video?.videoUrl || '');
+            if (!url) throw new Error('Each video album item requires a video URL');
+            return buildImaginePrimitive({ mediaType: 'video', url, thumbnail: video?.thumbnail || video?.thumbnailUrl, mimeType: video?.mimeType || video?.mime_type || 'video/mp4', fileLength: video?.fileLength || video?.file_length || 0, duration: video?.duration || 0, status: 'READY' });
+        }
+        const image = item?.image || item?.data || item;
+        const sourceUrl = typeof image === 'string' ? image : (image?.sourceUrl || image?.url || '');
+        if (!sourceUrl) throw new Error('Each image album item requires an image URL');
+        const previewUrl = image?.imagePreviewUrl || image?.previewUrl || sourceUrl;
+        const fullUrl = image?.imageHighResUrl || image?.highResUrl || image?.url || sourceUrl;
+        const width = image?.width || item?.width || 600;
+        const height = image?.height || item?.height || 400;
+        const mimeType = image?.mimeType || image?.mime_type || 'image/png';
+        return {
+            preview_image: { url: previewUrl, url_fallback: previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            full_image: { url: fullUrl, url_fallback: fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            dark_mode_preview_image: { url: image?.darkModePreviewUrl || previewUrl, url_fallback: image?.darkModePreviewUrl || previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            dark_mode_full_image: { url: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, url_fallback: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            display_mode: 'FULL_WIDTH',
+            full_width: true,
+            asset_query_status: 'FETCHED',
+            __typename: 'GenAIImagePrimitive'
+        };
+    });
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: randomUUID(), sections: [{ view_model: { primitives, display_mode: 'FULL_WIDTH', full_width: true, __typename: 'GenAIVStackLayoutViewModel' } }] })) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
+
+export const prepareVideoGridMessage = ({ videos = [], verificationMetadata } = {}) => {
+    if (!Array.isArray(videos) || videos.length < 2) {
+        throw new Error('Video grid requires at least two videos');
+    }
+    const primitives = videos.map((video) => {
+        const url = typeof video === 'string' ? video : (video?.url || video?.videoUrl || video?.reelsUrl || '');
+        if (!url) throw new Error('Each video-grid item requires a video URL');
+        const item = typeof video === 'string' ? {} : video;
+        return {
+            post_id: item.postId == null ? undefined : String(item.postId),
+            reels_url: url,
+            reels_title: item.title,
+            thumbnail_url: item.thumbnailUrl || item.thumbnail,
+            creator: item.creator,
+            avatar_url: item.avatarUrl,
+            content_hash: item.contentHash,
+            likes_count: item.likes,
+            comments_count: item.comments,
+            shares_count: item.shares,
+            is_verified: item.isVerified,
+            source_app: item.sourceApp,
+            video_delivery_response: {
+                progressive_urls: (item.progressiveUrls || []).map((value) => ({
+                    progressive_url: value,
+                    __typename: 'GenAIProgressiveUrlResponse'
+                })),
+                dash_manifests: (item.dashManifests || []).map((value) => ({
+                    manifest_xml: value,
+                    __typename: 'GenAIDashManifestResponse'
+                })),
+                __typename: 'GenAIVideoDeliveryResponse'
+            },
+            __typename: 'GenAIVideoPrimitive'
+        };
+    });
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+            view_model: {
+                primitives,
+                __typename: 'GenAIGridLayoutViewModel'
+            }
+        }]
+    };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
+
 export const prepareRichResponseMessage = (content) => {
     const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noDonation, noHeading, posts, products, reels, sources: sourceInputs, suggested, richResponse, table, tapLinkUrl, title, verificationMetadata } = content;
     let submessages = [];
+    const extraSections = [];
     if (Array.isArray(richResponse)) {
         submessages = richResponse.map((submessage) => {
             if (submessage.text) {
@@ -843,9 +1149,21 @@ export const prepareRichResponseMessage = (content) => {
             });
         }
         if (inlineVideo) {
-            submessages.push({
-                messageType: RichSubMessageType.TEXT,
-                messageText: 'INLINE_VIDEO'
+            const video = typeof inlineVideo === 'string' ? { url: inlineVideo } : inlineVideo;
+            submessages.push({ messageType: RichSubMessageType.TEXT, messageText: '[ CANNOT_LOAD_VIDEO - NIXEL ]' });
+            extraSections.push({
+                view_model: {
+                    primitive: buildImaginePrimitive({
+                        mediaType: 'video',
+                        url: video?.url || video?.videoUrl || '',
+                        mimeType: video?.mimeType || video?.mime_type || 'video/mp4',
+                        fileLength: video?.fileLength || video?.file_length || 0,
+                        duration: video?.duration || 0,
+                        thumbnail: video?.thumbnail,
+                        status: video?.status || 'READY'
+                    }),
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
             });
         }
         if (latex) {
@@ -863,7 +1181,40 @@ export const prepareRichResponseMessage = (content) => {
             title: 'PAIR CRYSN⚉VA AI ⩇⩇:⩇⩇',
             displayName: 'pair bot'
         };
-        const sourceLinks = (sourceInputs || links || []).map((linkField) => {
+        const rawSources = Array.isArray(sourceInputs) ? sourceInputs : [];
+        // Existing `sources: [{ url, displayName, subtitle }]` callers use
+        // citation entities. The serialized AIRich addSource format is the
+        // distinct tuple form: `[[faviconUrl, sourceUrl, displayText], ...]`.
+        const sourceTuples = rawSources.length > 0 && rawSources.every((source) => Array.isArray(source));
+        if (sourceTuples) {
+            const sourceCards = rawSources.map((source) => {
+                const item = Array.isArray(source)
+                    ? { icon: source[0], url: source[1], text: source[2] }
+                    : source;
+                const sourceUrl = item.url || item.sourceUrl || item.source_url || '';
+                return {
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: item.text || item.displayName || item.sourceDisplayName || '',
+                    source_subtitle: item.subtitle || 'AI',
+                    source_url: sourceUrl,
+                    favicon: {
+                        url: item.icon || item.iconUrl || item.favicon || '',
+                        mime_type: item.mimeType || 'image/jpeg',
+                        width: item.width || 16,
+                        height: item.height || 16
+                    }
+                };
+            }).filter((source) => source.source_url || source.source_display_name);
+            if (sourceCards.length) {
+                extraSections.push({
+                    view_model: {
+                        primitive: { sources: sourceCards, __typename: 'GenAISearchResultPrimitive' },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                });
+            }
+        }
+        const sourceLinks = (sourceTuples ? [] : (sourceInputs || links || [])).map((linkField) => {
             if (typeof linkField === 'string') return { text: '', url: linkField, displayName: linkField };
             return { text: linkField?.text || linkField?.displayName || linkField?.title || '', ...linkField };
         });
@@ -898,14 +1249,53 @@ export const prepareRichResponseMessage = (content) => {
         if (posts) {
             submessages.push({
                 messageType: RichSubMessageType.TEXT,
-                messageText: 'POSTS'
+                messageText: '[ CANNOT_LOAD_POST - NIXEL ]'
             });
+            const postItems = (Array.isArray(posts) ? posts : [posts]).map((post) => ({
+                title: post?.title || '',
+                subtitle: post?.subtitle || '',
+                username: post?.username || post?.user || '',
+                profile_picture_url: post?.profile_picture_url || post?.profile || post?.profile_url || '',
+                is_verified: !!(post?.is_verified ?? post?.verified),
+                thumbnail_url: post?.thumbnail_url || post?.thumbnail || '',
+                post_caption: post?.post_caption || post?.caption || '',
+                likes_count: post?.likes_count ?? post?.like ?? 0,
+                comments_count: post?.comments_count ?? post?.comment ?? 0,
+                shares_count: post?.shares_count ?? post?.share ?? 0,
+                post_url: post?.post_url || post?.url || '',
+                post_deeplink: post?.post_deeplink || post?.deeplink || '',
+                source_app: post?.source_app || post?.source || '',
+                footer_label: post?.footer_label || post?.footer || '',
+                footer_icon: post?.footer_icon || post?.icon || '',
+                is_carousel: post?.is_carousel ?? true,
+                orientation: post?.orientation || 'LANDSCAPE',
+                post_type: post?.post_type || 'VIDEO',
+                __typename: 'GenAIPostPrimitive'
+            }));
+            if (postItems.length) extraSections.push({ view_model: { primitives: postItems, __typename: 'GenAIHScrollLayoutViewModel' } });
         }
         if (products) {
             submessages.push({
                 messageType: RichSubMessageType.TEXT,
-                messageText: 'PRODUCTS'
+                messageText: '[ CANNOT_LOAD_PRODUCT - NIXEL ]'
             });
+            const productItems = (Array.isArray(products) ? products : [products]).map((product) => ({
+                title: product?.title || '',
+                brand: product?.brand || '',
+                price: product?.price || '',
+                sale_price: product?.sale_price || product?.salePrice || '',
+                product_url: product?.product_url || product?.url || '',
+                image: { url: product?.image?.url || product?.image || '' },
+                additional_images: [{ url: product?.icon_url || product?.icon || '' }],
+                __typename: 'GenAIProductItemCardPrimitive'
+            }));
+            if (productItems.length) {
+                extraSections.push({
+                    view_model: Array.isArray(products)
+                        ? { primitives: productItems, __typename: 'GenAIHScrollLayoutViewModel' }
+                        : { primitive: productItems[0], __typename: 'GenAISingleLayoutViewModel' }
+                });
+            }
         }
         if (suggested) {
             submessages.push({
@@ -934,6 +1324,7 @@ export const prepareRichResponseMessage = (content) => {
     }
     const uuid = randomUUID();
     const unified = toUnified(submessages, uuid);
+    unified.sections = [...unified.sections.filter(Boolean), ...extraSections];
     const richResponseMessage = proto.AIRichResponseMessage.create({
         submessages,
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,

package/lib/index.d.ts

@@ -224,7 +224,8 @@ export interface RelayMessageOptions {
 
 export interface AlbumMediaInput {
     image?: unknown;
-    type?: 'image';
+    video?: unknown;
+    type?: 'image' | 'video';
     data?: unknown;
     sourceUrl?: string;
     imagePreviewUrl?: string;
@@ -246,10 +247,73 @@ export interface AnimatedWallpaperInput {
     opacity?: number;
 }
 
+export interface A2UIMessageContent {
+    image?: unknown;
+    bloksWidget?: { type?: string; data?: unknown; fallback?: string };
+    nativeFlowMessage?: { messageParamsJson?: string; buttons?: unknown[]; [key: string]: unknown };
+    [key: string]: unknown;
+}
+
+export interface A2UICommandMenuContent {
+    image?: unknown;
+    title?: string;
+    rows?: Array<[string, string, string?] | { title?: string; description?: string; id?: string }>;
+    buttons?: Array<{ text?: string; label?: string; url?: string }>;
+    fallback?: string;
+}
+
+export interface SocialEntityContent {
+    username?: string;
+    platform?: string;
+    title?: string;
+    subtitle?: string;
+    imageUrl?: string;
+    entityId?: string | number;
+    entityUrl?: string;
+    entityType?: string;
+    fullName?: string;
+    isVerified?: boolean;
+    resultText?: string;
+    botJid?: string;
+    responseId?: string;
+}
+
+export interface AIRichCommandMenuContent {
+    image: string;
+    title?: string;
+    subtitle?: string;
+    code?: string;
+    rows?: Array<[string, string] | { command?: string; description?: string }>;
+    latexImage?: string;
+    latexExpression?: string;
+    buttons?: Array<{ id?: string; text?: string; label?: string; url?: string; toast?: string }>;
+    footer?: string;
+}
+
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
-    /** Send at least two image URL items as an AIRich GRID_IMAGE album. */
+    /** Send at least two image/video URL items as a full-width AIRich vertical album. */
     sendAlbumMessage(jid: string, medias: AlbumMediaInput[], options?: Record<string, unknown>): Promise<unknown>;
+    /** Send an AIRich unified-response grid of GenAIVideoPrimitive items. Requires at least two video URLs. */
+    sendVideoGridMessage(jid: string, videos: Array<string | {
+        url?: string;
+        videoUrl?: string;
+        reelsUrl?: string;
+        postId?: string | number;
+        title?: string;
+        thumbnailUrl?: string;
+        thumbnail?: string;
+        creator?: string;
+        avatarUrl?: string;
+        contentHash?: string;
+        likes?: number;
+        comments?: number;
+        shares?: number;
+        isVerified?: boolean;
+        sourceApp?: string;
+        progressiveUrls?: string[];
+        dashManifests?: string[];
+    }>, options?: Record<string, unknown>): Promise<unknown>;
     /** Update the connected account's WhatsApp About/profile status. */
     updateProfileStatus(status: string): Promise<void>;
     /** Update the connected account's profile name. */
@@ -260,6 +324,16 @@ export interface WASocket {
     relayMessage(jid: string, message: Record<string, unknown>, options?: RelayMessageOptions): Promise<unknown>;
     /** Send an experimental Meta AI-style rich menu with image, card buttons, and an optional URL footer. */
     richMenu(jid: string, content?: RichMenuContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a provider-neutral AIRich social/entity result card. */
+    sendSocialEntity(jid: string, content?: SocialEntityContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the primary Instagram profile result using the universal social/entity format. */
+    sendInstagramProfile(jid: string, content: SocialEntityContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send arbitrary A2UI/interactive payloads with immediate relay/edit rendering. */
+    sendA2UIMessage(jid: string, content?: A2UIMessageContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the large A2UI card/menu with an image header, command table, URL buttons, and native-flow selector. */
+    sendA2UICommandMenu(jid: string, content?: A2UICommandMenuContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the manually serialized AIRich command card with image, Markdown, widget CTAs, and footer actions. */
+    sendAIRichCommandMenu(jid: string, content: AIRichCommandMenuContent, options?: Record<string, unknown>): Promise<unknown>;
     /** Send raw HTML through the experimental WhatsApp HTML primitive. */
     sendHtmlMessage(jid: string, content: { html: string; trustedSources?: string[] }, options?: Record<string, unknown>): Promise<unknown>;
     /** Post a personal status using explicit viewers or a configured contact source/provider. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plogme",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Production-ready Baileys fork ⚉ with AI groups, Meta AI prompting, safe compositing fallbacks, rich responses, interactive messages, albums, newsletters, and communities — without antiban wrappers.",
   "main": "lib/index.js",
   "type": "module",