plogme 2.0.5 → 2.0.6

package/README.md

@@ -625,6 +625,103 @@ await sock.sendRichLink(jid, {
 })
 ```
 
+### Instagram profile card with AI summary
+
+`sendInstagramProfile` builds the complete unified-response structure: a compact profile entity, divider, and clickable social-profile summary. The summary is encoded as an inline `GenAISocialEntityItem`, not as ordinary plain text.
+
+```js
+await sock.sendInstagramProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  subtitle: '⚉',
+  imageUrl: 'https://cdn.example/profile.png',
+  entityId: '123456',
+  entityUrl: 'https://www.instagram.com/crysnovax',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'See results'
+})
+```
+
+The same complete card and clickable summary are available for other platforms:
+
+```js
+await sock.sendFacebookProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/facebook.png',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'Open Facebook profile'
+})
+
+await sock.sendTikTokProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/tiktok.png',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'Open TikTok profile'
+})
+
+await sock.sendYouTubeProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/youtube.png',
+  fullName: 'CRYSNOVAX',
+  resultText: 'Open YouTube channel'
+})
+
+await sock.sendXProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/x.png',
+  fullName: 'CRYSNOVAX',
+  resultText: 'Open X profile'
+})
+```
+
+For a platform not covered by a named helper, use `sendSocialProfile` and supply the platform, entity type, and URL explicitly:
+
+```js
+await sock.sendSocialProfile(jid, {
+  platform: 'linkedin',
+  entityType: 'LINKEDIN_PROFILE',
+  username: 'crysnovax',
+  entityUrl: 'https://www.linkedin.com/in/crysnovax',
+  title: 'CODY AI',
+  resultText: 'Open LinkedIn profile'
+})
+```
+
+### Complete custom unified responses
+
+For newer WhatsApp primitives that do not yet have a dedicated helper, use `sendUnifiedResponse`. It preserves the complete `sections`, `view_model`, `primitives`, and inline entity objects you provide.
+
+```js
+await sock.sendUnifiedResponse(jid, {
+  sections: [
+    {
+      view_model: {
+        primitives: [
+          {
+            __typename: 'GenAIQueryPlanPrimitive',
+            title: 'Query plan',
+            steps: [
+              { title: 'Search', status: 'PLANNED' },
+              { title: 'Summarize', status: 'PLANNED' }
+            ]
+          }
+        ],
+        __typename: 'GenAIActionRowLayoutViewModel'
+      }
+    }
+  ]
+})
+```
+
+This path is useful for protocol structures that are already present in `WAProto` but are not yet normalized by a named convenience builder. It sends the payload through normal WhatsApp message generation before relay.
+
 ### Rich tables, lists, code, and LaTeX
 
 ```js
@@ -1194,6 +1291,24 @@ await sock.sendBotToolResult(jid, {
 })
 ```
 
+### Planning metadata and tool results
+
+`sendBotPlan` serializes the generated `BotProgressIndicatorMetadata` structure and advertises the `AGENTIC_PLANNING` and `QUERY_PLAN` capabilities defined in `WAProto`. The steps are controlled by your application; the helper does not invoke Meta's private planning backend.
+
+```js
+await sock.sendBotPlan(jid, {
+  title: 'Deployment plan',
+  text: 'I will check, deploy, and verify the service.',
+  steps: [
+    { title: 'Health check', description: 'Check the API and database', status: 'planned' },
+    { title: 'Deploy', description: 'Publish the verified build', status: 'executing' },
+    { title: 'Verify', description: 'Confirm the public endpoint', status: 'finished' }
+  ]
+})
+```
+
+`sendBotToolResult` carries the resolved tool-call metadata and advertises `QUERY_PLAN` so a tool result can be associated with a planning flow. It does not execute the tool. Your application must validate the tool name, arguments, permissions, and result before calling it.
+
 These methods do not provide Meta's private verification credentials and must not be used to impersonate a first-party Meta AI message.
 
 ## WhatsApp flows and web views

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, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareInstagramProfileMessage, 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';
@@ -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);
@@ -2535,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,
@@ -2547,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, {

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: {
@@ -436,6 +452,7 @@ export const prepareSocialEntityMessage = ({
                                 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,
@@ -473,7 +490,7 @@ export const prepareSocialEntityMessage = ({
 };
 
 /** Dedicated Instagram profile card using the universal social-entity wire format. */
-export const prepareInstagramProfileMessage = (content = {}) => prepareSocialEntityMessage({
+export const prepareInstagramProfileMessage = (content = {}) => prepareSocialProfileMessage({
     ...content,
     platform: 'INSTAGRAM',
     entityType: 'IG_PROFILE',
@@ -917,23 +934,13 @@ 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, 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 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: [],
@@ -1002,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 = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plogme",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "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",