plogme 2.0.4 → 2.0.6

package/lib/Socket/chats.js

@@ -1863,6 +1863,9 @@ export const makeChatsSocket = (config) => {
         getUserDisclosures,
         acceptTosNotice,
         reportSpam,
+        reportUser,
+        reportMessage,
+        reportAndBlockUser,
         toggleGroupHistory,
         getOptOutList,
         signPrivateCredential,

package/lib/Socket/messages-send.js

@@ -5,7 +5,7 @@ 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, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.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 { prepareRichMenuMessage, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareSocialProfileMessage, prepareUnifiedResponseMessage, 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';
@@ -1051,7 +1051,7 @@ export const makeMessagesSocket = (config) => {
         await relayMessage(jid, fullMsg.message, relayOptions);
 
         const richEnvelope = fullMsg.message?.botForwardedMessage?.message?.richResponseMessage;
-        if (options.renderRichResponse !== false && richEnvelope) {
+        if (options.renderRichResponse !== false && (richEnvelope || options.forceRichEdit || fullMsg.message?.interactiveMessage?.bloksWidget)) {
             const editContent = proto.Message.fromObject({
                 botForwardedMessage: {
                     message: {
@@ -2370,6 +2370,76 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    const sendSocialProfile = async (methodName, jid, content, options, prepare) => {
+        if (!jid) throw new Boom(`${methodName} requires a target JID`, { statusCode: 400 });
+        const wrapped = prepare(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
+        });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+    socket.sendSocialProfile = async (jid, content = {}, options = {}) => sendSocialProfile('sendSocialProfile', jid, content, options, prepareSocialProfileMessage);
+    socket.sendInstagramProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendInstagramProfile',
+        jid,
+        { ...content, platform: 'instagram', entityType: content.entityType || 'IG_PROFILE', entityUrl: content.entityUrl || `https://www.instagram.com/${content.username || ''}` },
+        options,
+        prepareInstagramProfileMessage
+    );
+    socket.sendFacebookProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendFacebookProfile', jid,
+        { ...content, platform: 'facebook', entityType: content.entityType || 'FB_PROFILE', entityUrl: content.entityUrl || `https://www.facebook.com/${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendTikTokProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendTikTokProfile', jid,
+        { ...content, platform: 'tiktok', entityType: content.entityType || 'TIKTOK_PROFILE', entityUrl: content.entityUrl || `https://www.tiktok.com/@${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendYouTubeProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendYouTubeProfile', jid,
+        { ...content, platform: 'youtube', entityType: content.entityType || 'YOUTUBE_PROFILE', entityUrl: content.entityUrl || `https://www.youtube.com/@${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendXProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendXProfile', jid,
+        { ...content, platform: 'x', entityType: content.entityType || 'X_PROFILE', entityUrl: content.entityUrl || `https://x.com/${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendUnifiedResponse = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendUnifiedResponse requires a target JID', { statusCode: 400 });
+        const wrapped = prepareUnifiedResponseMessage(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
+        });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
     socket.richMenu = async (jid, content = {}, options = {}) => {
         if (!jid) throw new Boom('richMenu requires a target JID', { statusCode: 400 });
         const wrapped = prepareRichMenuMessage(content);
@@ -2407,7 +2477,7 @@ export const makeMessagesSocket = (config) => {
             messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
             ...options,
         });
-        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, ...options.relayOptions });
+        await relayRichMessage(jid, fullMsg, { ...options, forceRichEdit: true });
         if (config.emitOwnEvents) {
             process.nextTick(async () => {
                 await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
@@ -2415,6 +2485,27 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    /** Send arbitrary A2UI/interactive payloads; sendA2UICommandMenu is a preset wrapper. */
+    socket.sendA2UIMessage = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendA2UIMessage requires a target JID', { statusCode: 400 });
+        const { image, ...payload } = content || {};
+        let imageMessage;
+        if (image) {
+            const prepared = await prepareWAMessageMedia({ image }, { upload: waUploadToServer });
+            imageMessage = prepared.imageMessage;
+        }
+        const wrapped = prepareA2UIMessage({ ...payload, imageMessage });
+        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, forceRichEdit: true });
+        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 });
@@ -2433,6 +2524,36 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    /** Send a provider-neutral AIRich social/entity result card. */
+    socket.sendSocialEntity = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendSocialEntity requires a target JID', { statusCode: 400 });
+        const wrapped = prepareSocialEntityMessage(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')); });
+        return fullMsg;
+    };
+
+    /** Send the primary Instagram profile result using the universal social/entity API. */
+    socket.sendInstagramProfile = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendInstagramProfile requires a target JID', { statusCode: 400 });
+        const wrapped = prepareInstagramProfileMessage(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')); });
+        return fullMsg;
+    };
+
     /** Sends a rich response with experimental BotInfrastructureDiagnostics metadata. */
     socket.sendBotDiagnostics = async (jid, content = {}, options = {}) => {
         if (!jid) throw new Boom('sendBotDiagnostics requires a target JID', { statusCode: 400 });
@@ -2484,7 +2605,7 @@ export const makeMessagesSocket = (config) => {
         const wrapped = buildBotRichResponse({
             text,
             botJid,
-            capabilities: [BotCapabilityType.AGENTIC_PLANNING],
+            capabilities: [BotCapabilityType.AGENTIC_PLANNING, BotCapabilityType.QUERY_PLAN],
             botMetadata: {
                 resolvedToolCallMetadata: {
                     toolCallId,
@@ -2496,6 +2617,58 @@ export const makeMessagesSocket = (config) => {
         await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
+    /**
+     * Sends a real BotProgressIndicatorMetadata planning envelope. The plan is
+     * application-controlled; this advertises the public schema capability but
+     * does not claim to invoke Meta's private planning backend.
+     */
+    socket.sendBotPlan = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotPlan requires a target JID', { statusCode: 400 });
+        const {
+            text = 'Execution plan',
+            title = 'Execution plan',
+            steps = [],
+            estimatedCompletionTime,
+            botJid = '867051314767696@bot'
+        } = content;
+        if (!Array.isArray(steps) || steps.length === 0) {
+            throw new Boom('sendBotPlan requires at least one step', { statusCode: 400 });
+        }
+        const planningStatus = proto.BotProgressIndicatorMetadata.BotPlanningStepMetadata.PlanningStepStatus;
+        const normalizedSteps = steps.map((step, index) => ({
+            statusTitle: String(step.title || step.name || `Step ${index + 1}`),
+            statusBody: String(step.body || step.description || ''),
+            status: step.status === 'executing' ? planningStatus.EXECUTING
+                : step.status === 'finished' || step.status === 'completed' ? planningStatus.FINISHED
+                    : planningStatus.PLANNED,
+            isReasoning: step.isReasoning === true,
+            isEnhancedSearch: step.isEnhancedSearch === true,
+            ...(Array.isArray(step.sections) ? { sections: step.sections } : {})
+        }));
+        const wrapped = {
+            messageContextInfo: { botMetadata: {
+                    capabilityMetadata: {
+                        capabilities: [
+                            proto.BotCapabilityMetadata.BotCapabilityType.AGENTIC_PLANNING,
+                            proto.BotCapabilityMetadata.BotCapabilityType.QUERY_PLAN
+                        ]
+                    },
+                    progressIndicatorMetadata: {
+                        progressDescription: title,
+                        stepsMetadata: normalizedSteps,
+                        ...(estimatedCompletionTime ? { estimatedCompletionTime } : {})
+                    }
+                } },
+            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 });
+        return fullMsg;
+    };
     socket.sendStatus = async (content, options = {}) => {
         const statusJidList = await resolveStatusRecipients(options.statusJidList || content?.statusJidList);
         return socket.sendMessage(STATUS_JID, {
@@ -2792,11 +2965,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, forceRichEdit: true });
         return fullMsg;
     };
 

package/lib/Utils/messages.js

@@ -1592,7 +1592,16 @@ export const generateWAMessageContent = async (message, options) => {
         m = { lottieStickerMessage: { message: m } };
     }
     else if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
-        m = { viewOnceMessage: { message: m } };
+        // Text view-once clients expect the flag on the inner
+        // ExtendedTextMessage. Media continues to use the standard outer
+        // viewOnceMessage envelope.
+        if (m.extendedTextMessage) {
+            m.extendedTextMessage.viewOnce = true;
+        }
+        else {
+            m = { viewOnceMessage: { message: m } };
+        }
+        delete message.viewOnce;
     }
     // Lia@Changes 03-02-26 --- Add "viewOnceV2" boolean to wrap message into viewOnceMessageV2 like "viewOnce"
     else if (hasOptionalProperty(message, 'viewOnceV2') && !!message.viewOnceV2) {

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

@@ -5,6 +5,7 @@
  * If you use or copy this code, please credit my name or project. AND DO NOT CHANGE THIS NOTE
  */
 import { getRandomValues, randomUUID, randomBytes } from 'crypto';
+import { Boom } from '@hapi/boom';
 import { BOT_RENDERING_CONFIG_METADATA, DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
 import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
 import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
@@ -44,6 +45,38 @@ export const tokenizeCode = (code, language = 'javascript') => {
     }
     return blocks;
 };
+const firstImageValue = (...values) => values.find(value => value !== undefined && value !== null && String(value).length > 0);
+
+/** Normalize album image variants without downgrading full-size URLs to previews. */
+const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000)) => {
+    const previewUrl = firstImageValue(image.imagePreviewUrl, image.previewUrl, image.preview_url, image.sourceUrl, image.source_url, image.url) || '';
+    const fullUrl = firstImageValue(image.imageHighResUrl, image.highResUrl, image.high_res_url, image.fullUrl, image.full_url, image.sourceUrl, image.source_url, image.url, previewUrl);
+    const darkPreviewUrl = firstImageValue(image.darkModePreviewUrl, image.dark_mode_preview_url, previewUrl);
+    const darkFullUrl = firstImageValue(image.darkModeHighResUrl, image.darkModeHighResUrl, image.dark_mode_high_res_url, image.darkModePreviewUrl, image.dark_mode_preview_url, fullUrl);
+    const width = Number(image.previewWidth || image.preview_width || image.width || 600);
+    const height = Number(image.previewHeight || image.preview_height || image.height || 400);
+    const fullWidth = Number(image.fullWidth || image.full_width || image.highResWidth || image.high_res_width || image.width || width);
+    const fullHeight = Number(image.fullHeight || image.full_height || image.highResHeight || image.high_res_height || image.height || height);
+    const darkWidth = Number(image.darkWidth || image.dark_width || fullWidth);
+    const darkHeight = Number(image.darkHeight || image.dark_height || fullHeight);
+    const mimeType = image.mimeType || image.mime_type || 'image/png';
+    const media = (url, mediaWidth, mediaHeight) => ({
+        url,
+        url_fallback: url,
+        mime_type: mimeType,
+        expiration_timestamp_ms: expiration,
+        width: mediaWidth,
+        height: mediaHeight
+    });
+    return {
+        preview_image: media(previewUrl, width, height),
+        full_image: media(fullUrl, fullWidth, fullHeight),
+        dark_mode_preview_image: media(darkPreviewUrl, darkWidth, darkHeight),
+        dark_mode_full_image: media(darkFullUrl, darkWidth, darkHeight),
+        asset_query_status: 'FETCHED',
+        __typename: 'GenAIImagePrimitive'
+    };
+};
 // Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
 export const toUnified = (submessages, uuid) => ({
     response_id: uuid || randomUUID(),
@@ -66,24 +99,7 @@ export const toUnified = (submessages, uuid) => ({
                 const imageUrls = submessage.gridImageMetadata?.imageUrls || [];
                 if (!imageUrls.length) return null;
                 const expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000);
-                const primitives = imageUrls.map(img => {
-                    const previewUrl = img.imagePreviewUrl || img.sourceUrl || '';
-                    const fullUrl = img.imageHighResUrl || img.imagePreviewUrl || img.sourceUrl || '';
-                    const width = img.width || 600;
-                    const height = img.height || 400;
-                    const darkPreviewUrl = img.darkModePreviewUrl || previewUrl;
-                    const darkFullUrl = img.darkModeHighResUrl || img.darkModePreviewUrl || fullUrl;
-                    const darkWidth = img.darkWidth || width;
-                    const darkHeight = img.darkHeight || height;
-                    return {
-                        preview_image: { url: previewUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width, height },
-                        full_image: { url: fullUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width, height },
-                        dark_mode_preview_image: { url: darkPreviewUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width: darkWidth, height: darkHeight },
-                        dark_mode_full_image: { url: darkFullUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width: darkWidth, height: darkHeight },
-                        asset_query_status: 'FETCHED',
-                        __typename: 'GenAIImagePrimitive'
-                    };
-                });
+                const primitives = imageUrls.map(img => buildRichImagePrimitive(img, expiration));
                 return { view_model: { primitives, __typename: 'GenAIGridLayoutViewModel' } };
             }
             case RichSubMessageType.CONTENT_ITEMS: {
@@ -376,6 +392,111 @@ 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,
+                                platform: String(platform || 'GENERIC').toUpperCase(),
+                                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 = {}) => prepareSocialProfileMessage({
+    ...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 = [];
@@ -500,6 +621,29 @@ export const prepareAIRichCommandMenu = ({ image, title = 'CODY AI', subtitle =
     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');
@@ -790,26 +934,18 @@ export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata }
             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 || '');
+        const sourceUrl = typeof image === 'string' ? image : firstImageValue(
+            image?.imageHighResUrl, image?.highResUrl, image?.fullUrl,
+            image?.imagePreviewUrl, image?.previewUrl, 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, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            full_image: { url: fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            dark_mode_preview_image: { url: image?.darkModePreviewUrl || previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            dark_mode_full_image: { url: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            asset_query_status: 'FETCHED',
-            __typename: 'GenAIImagePrimitive'
-        };
+        const primitive = buildRichImagePrimitive({ ...image, width: image?.width || item?.width, height: image?.height || item?.height }, expiration);
+        return { ...primitive, display_mode: 'FULL_WIDTH', full_width: true };
     });
     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, __typename: 'GenAIVStackLayoutViewModel' } }] })) },
+        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);
@@ -873,6 +1009,107 @@ export const prepareVideoGridMessage = ({ videos = [], verificationMetadata } =
     return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
 };
 
+/**
+ * Builds a compact social-profile card used by WhatsApp's unified response
+ * renderer. The summary is an inline social entity, not ordinary plain text.
+ */
+export const prepareSocialProfileMessage = (options = {}) => {
+    const {
+        username,
+        platform = 'instagram',
+        title = 'CODY AI',
+        subtitle = '⚉',
+        imageUrl = '',
+        entityId = username,
+        entityUrl = `https://www.${platform}.com/${username || ''}`,
+        entityType = platform === 'instagram' ? 'IG_PROFILE' : `${String(platform).toUpperCase()}_PROFILE`,
+        fullName = 'NOT found',
+        isVerified = false,
+        resultText = 'See results'
+    } = options;
+    if (!username || typeof username !== 'string') {
+        throw new Boom('sendSocialProfile requires a username', { statusCode: 400 });
+    }
+    const image = imageUrl ? { url: imageUrl, mime_type: 'image/png' } : undefined;
+    const sections = [
+        {
+            view_model: {
+                primitives: [{
+                    title,
+                    subtitle,
+                    ...(image ? { image } : {}),
+                    entity_id: String(entityId || username),
+                    entity_url: entityUrl,
+                    entity_type: 'WEBSITE',
+                    action_type: 'OPEN_URL',
+                    is_verified: Boolean(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: username,
+                                entity_name: username,
+                                entity_full_name: fullName,
+                                platform: String(platform || 'GENERIC').toUpperCase(),
+                                entity_picture_url: imageUrl,
+                                entity_url: entityUrl,
+                                entity_type: entityType,
+                                is_verified: Boolean(isVerified)
+                            }
+                        }],
+                        __typename: 'GenAIMarkdownTextUXPrimitive'
+                    },
+                    { __typename: 'GenAISpacerPrimitive' }
+                ],
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        }
+    ];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ sections })) },
+        contextInfo: { isForwarded: true, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+
+/**
+ * Builds a generic unified-response envelope without reducing its sections to
+ * plain text. This is the extension point for newer WhatsApp primitives that
+ * are present in WAProto but do not yet have a dedicated convenience helper.
+ */
+export const prepareUnifiedResponseMessage = ({ sections = [], submessages = [], responseId = randomUUID(), contextInfo } = {}) => {
+    if (!Array.isArray(sections) || sections.length === 0) {
+        throw new Boom('sendUnifiedResponse requires at least one section', { statusCode: 400 });
+    }
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: responseId, sections })) },
+        contextInfo: contextInfo || { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
 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 = [];