plogme 2.0.9 → 2.1.1

package/README.md

@@ -326,8 +326,24 @@ await sock.sendMessage(jid, {
     canAddOption: false
   }
 })
+
+// Photo polls: each image is uploaded and sent as a MEDIA_POLL-associated child.
+// Values without an image can be mixed in with image options.
+await sock.sendMessage(channelJid, {
+  poll: {
+    name: 'Choose a cover',
+    values: [
+      { name: 'Purple', image: { url: './purple-cover.jpg' } },
+      { name: 'Blue', image: { url: './blue-cover.jpg' } },
+      'Other'
+    ],
+    selectableCount: 1
+  }
+})
 ```
 
+Photo polls use WhatsApp's experimental image-poll format: a V3 poll with `pollContentType: IMAGE`, option hashes, and separately associated `pollCreationOptionImageMessage` children. Forwarding a received poll with a generic one-message forward does not automatically collect and resend those associated image children.
+
 ### Latest WAProto additions
 
 The WAProto generation is updated to WhatsApp Web revision
@@ -417,6 +433,13 @@ await sock.sendMessage(jid, {
 await sock.sendMessage(jid, {
   sticker: { url: './sticker.webp' }
 })
+
+// AI and avatar-style protected sticker markers
+await sock.sendMessage(jid, {
+  sticker: { url: './sticker.webp' },
+  meta: true, // native StickerMessage.isAiSticker
+  lock: true  // native avatar-style marker; WhatsApp has no literal lock field
+})
 ```
 
 Remote URLs, local file paths, and buffers are supported where the selected media helper accepts them.
@@ -1003,6 +1026,20 @@ const result = await sock.sendPlogmeMessage(jid, {
     verified: true
   }],
 
+  // Optional raw HTML section, composed into this same unified response.
+  html: '<section><h2>Deployment</h2><p>Ready</p></section>',
+  trustedSources: ['crysnovax.com'],
+
+  // Optional tabbed HTML screen, using the same format as sendRichHtmlMessage.
+  richHtml: {
+    title: 'Service dashboard',
+    url: 'https://crysnovax.com/dashboard',
+    tabs: [
+      { tab_header: 'Overview', html: '<h1>Overview</h1>' },
+      { tab_header: 'Logs', html: '<h1>Logs</h1>' }
+    ]
+  },
+
   // Optional source cards: [favicon URL, source URL, display text].
   sources: [[
     'https://example.com/favicon.jpg',
@@ -1029,6 +1066,8 @@ const result = await sock.sendPlogmeMessage(jid, {
 console.log('Sent message:', result.key.id)
 ```
 
+`sendPlogmeMessage` accepts both HTML formats: `html` uses the same `FOAHtmlPrimitiveDemoDONOTUSE` primitive as `sendHtmlMessage`, while `richHtml` uses the tabbed `GenAIaeacdsnwHtmlPrimitive` format from `sendRichHtmlMessage`. They can be included together in one response. Alternatively, pass the tabbed config as `html: { title, url, tabs, trustedSources }`.
+It also composes the compatible standalone AIRich helpers in the same response: `copyButton`/`copyToClipboard`, `richText`, `quote`, `richImage`, `richLinks`, `richMap`/`map`, `dynamicMedia`/`richDynamicMedia`, `socialEntity`, `socialProfile`, `richMenu`, `airichCommandMenu`, `gridImages`, `verticalAlbum`, `videoGrid`, `richGeneration`, `richLabel`, `suggestedPrompt`, `botSources`, and `botPttTranscript`. Use `sections` or `richSections` for newly discovered unified-response primitives, or `unifiedResponse: { sections, embedded_screens }` when passing an already serialized section set. A2UI/native-flow payloads remain separate because they use an `interactiveMessage` envelope rather than AIRich's `unifiedResponse` envelope; use `sendA2UIMessage` for those.
 Every field in the example is optional. A minimal response is valid as well:
 
 ```js
@@ -2155,7 +2194,12 @@ await sock.sendMessage(groupJid, {
   mentions: ['628123456789@s.whatsapp.net'],
   groupStatus: true
 })
-
+// Compatibility test for the older groupStatusMessage envelope.
+await sock.sendMessage(groupJid, {
+  text: 'Legacy group-status test',
+  groupStatus: true,
+  groupStatusVersion: 'legacy'
+})
 // Delete using the key returned by the original group-status send.
 // The group JID must match key.remoteJid when that field is present.
 await sock.deleteGroupStatus(groupJid, groupStatus.key)
@@ -2296,8 +2340,73 @@ await sock.sendMessage('status@broadcast', {
 
 Named, hex, and ARGB colors are accepted. Viewer JIDs are normalized and deduplicated.
 
-### Status Mentions
+### Named custom audiences
+
+A normal status can be restricted to a named status audience. This is different from a group status: it is still sent through `status@broadcast`, while the audience is configured through status privacy lists. The list name and emoji are rendered by the WhatsApp client when supported.
+
+```javascript
+const audienceMembers = [
+  '15551234567@s.whatsapp.net',
+  '15557654321@s.whatsapp.net'
+]
+
+await sock.setStatusPrivacy('whitelist', audienceMembers, [
+  {
+    id: 'cody-test-audience',
+    listname: 'Cody AI Testers',
+    emoji: '🧸',
+    selected: true,
+    members: audienceMembers
+  }
+])
+
+await sock.sendStatus(
+  { text: 'Only the selected custom audience can see this status.' },
+  { statusJidList: audienceMembers }
+)
+
+console.log(await sock.getStatusPrivacy())
+```
+
+Supported status privacy distribution types are `contacts`, `whitelist`, `blacklist`, and `null`. Named lists use the `customlist` status-privacy entry. A custom list does not turn the status into a group status, and the group JID itself must not be used as a status viewer; expand a group to its participant JIDs first.
+
+### Group status versus custom-audience status
+
+These are separate WhatsApp features:
+
+| Feature | Destination | Content flag/envelope | Result |
+| --- | --- | --- | --- |
+| Normal status | `status@broadcast` | `status: true` or `sendStatus()` | Personal status with selected viewers or privacy audience |
+| Custom-audience status | `status@broadcast` | Normal status plus status privacy/custom-list configuration | Native “custom audience” experience where supported by the client |
+| Group status | A group JID | `groupStatus: true` | Status attached to the group with “Added by …” and “Reply to group” UI |
+| Status mention | Array of user/group JIDs | `sendStatusMention()` or array destination | Status plus mention notification |
+
+Plogme's default group-status wire envelope is `groupStatusMessageV2`. For compatibility testing, the older envelope can be selected explicitly with `groupStatusVersion: 'legacy'` (or `'v1'`). This selector applies only to group status and does not configure a custom audience.
+
+For example, this tests the older group-status envelope in the supplied group without adding Cody or changing group membership:
+
+```javascript
+const testGroupJid = '120363406852054490@g.us'
+
+await sock.sendMessage(testGroupJid, {
+  text: 'Legacy group-status test',
+  groupStatus: true,
+  groupStatusVersion: 'legacy'
+})
+```
+
+The default V2 test is:
+
+```javascript
+await sock.sendMessage(testGroupJid, {
+  text: 'V2 group-status test',
+  groupStatus: true
+})
+```
+
+`groupStatusMessage` and `groupStatusMessageV2` are the two group-status protocol wrappers. They are not the same as `statusMentionMessage`, `groupStatusMentionMessage`, or the normal status/custom-audience path. `aiGroupAddBot()` is unrelated to all of these status APIs and is not required to send either group-status variant.
 
+### Status Mentions
 Passing an array as the destination posts a status and sends mention notifications to those contacts or groups. This is intentionally separate from `statusJidList`, which controls viewers without mentioning them.
 
 ```javascript

package/lib/Socket/messages-send.js

@@ -3,7 +3,7 @@ import { Boom } from '@hapi/boom';
 import { randomBytes, randomUUID } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, generateWAMessageFromImagePoll, 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, prepareSocialProfileMessage, prepareUnifiedResponseMessage, prepareRichMapMessage, prepareBotPromptSuggestionsMessage, prepareBotSourcesMessage, prepareRichDynamicMediaMessage, prepareBotPttTranscriptMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, buildRichLabelMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
@@ -1093,6 +1093,31 @@ export const makeMessagesSocket = (config) => {
         return fullMsg;
     };
 
+    const sendImagePoll = async (jid, poll, sendOptions = {}) => {
+        const userJid = authState.creds.me.id;
+        const { additionalNodes: _callerNodes, ...relayBaseOptions } = sendOptions;
+        return generateWAMessageFromImagePoll(jid, poll, async (message, relayOptions, fullMessage) => {
+            await relayMessage(jid, message, {
+                ...relayBaseOptions,
+                useCachedGroupMetadata: sendOptions.useCachedGroupMetadata,
+                statusJidList: sendOptions.statusJidList,
+                statusPrivacy: sendOptions.statusPrivacy,
+                ...relayOptions
+            });
+            if (config.emitOwnEvents && fullMessage) {
+                process.nextTick(async () => {
+                    await messageMutex.mutex(() => upsertMessage(fullMessage, 'append'));
+                });
+            }
+        }, {
+            logger,
+            userJid,
+            upload: waUploadToServer,
+            mediaCache: config.mediaCache,
+            options: config.options,
+            ...sendOptions
+        });
+    };
     const getMessageType = (message) => {
         if (!message)
             return 'text';
@@ -1576,7 +1601,7 @@ export const makeMessagesSocket = (config) => {
          * section present in `content`. Missing sections are intentionally
          * ignored by prepareRichResponseMessage instead of causing a partial
          * response to fail. This is the stable entry point for Plogme/CODY
-         * callers that may receive optional text, links, media, products,
+         * callers that may receive optional text, HTML, links, media, products,
          * reels, tables, code, latex, or suggestion data.
          */
         sendPlogmeMessage: async (jid, content = {}, quoted, options = {}) => {
@@ -1807,6 +1832,10 @@ export const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            const pollValues = content?.poll?.values;
+            if (Array.isArray(pollValues) && pollValues.some(value => value && typeof value === 'object' && value.image)) {
+                return sendImagePoll(jid, content.poll, options);
+            }
             if (content?.groupStatus === true && !isJidGroup(jid)) {
                 throw new Boom('groupStatus requires a valid group JID', { statusCode: 400 });
             }
@@ -3025,6 +3054,27 @@ export const makeMessagesSocket = (config) => {
         return fullMsg;
     };
 
+    /**
+     * Send a native group status. `content.private` adds WhatsApp's
+     * statusAudienceMetadata without creating a group message or changing
+     * group membership.
+     */
+    socket.sendGroupStatus = async (jid, content = {}, options = {}) => {
+        if (!jid || !isJidGroup(jid)) {
+            throw new Boom('sendGroupStatus requires a valid group JID', { statusCode: 400 });
+        }
+        if (!content || typeof content !== 'object' || Array.isArray(content)) {
+            throw new Boom('sendGroupStatus content must be a message object', { statusCode: 400 });
+        }
+        const { private: privateAudience, ...statusContent } = content;
+        const audience = privateAudience ?? options.private;
+        return socket.sendMessage(
+            jid,
+            { ...statusContent, groupStatus: true, ...(audience !== undefined ? { private: audience } : {}) },
+            options
+        );
+    };
+
 
     /**
      * Sends an HTML message — renders raw HTML inside the chat bubble.

package/lib/Utils/messages.js

@@ -92,6 +92,21 @@ export const prepareWAMessageMedia = async (message, options) => {
     if (!uploadData.mimetype) {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
     }
+    if (mediaType === 'sticker') {
+        // @neoxr/wb names the native AI-sticker marker `meta`. WhatsApp's
+        // current StickerMessage schema exposes this as `isAiSticker`.
+        if (hasOptionalProperty(message, 'meta')) {
+            uploadData.isAiSticker = !!message.meta;
+            delete uploadData.meta;
+        }
+        // There is no protobuf field literally named `lock`. WhatsApp's
+        // compatible native marker for stickers that should not be saved is
+        // the avatar-sticker bit, which is what current clients inspect.
+        if (hasOptionalProperty(message, 'lock')) {
+            uploadData.isAvatar = !!message.lock;
+            delete uploadData.lock;
+        }
+    }
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -882,6 +897,33 @@ export const generateWAMessageContent = async (message, options) => {
         m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
         m.eventMessage.location = message.event.location;
     }
+    else if (hasNonNullishProperty(message, 'imagePoll')) {
+        const imagePoll = message.imagePoll;
+        if (!Array.isArray(imagePoll.options) || imagePoll.options.length < 2 || imagePoll.options.length > 12) {
+            throw new Boom('imagePoll.options must contain between 2 and 12 options', { statusCode: 400 });
+        }
+        const selectableOptionsCount = imagePoll.selectableCount ?? 1;
+        if (selectableOptionsCount < 0 || selectableOptionsCount > imagePoll.options.length) {
+            throw new Boom(`imagePoll.selectableCount should be >= 0 and <= ${imagePoll.options.length}`, {
+                statusCode: 400
+            });
+        }
+        m.pollCreationMessageV3 = {
+            name: imagePoll.name,
+            selectableOptionsCount,
+            options: imagePoll.options.map(option => ({
+                optionName: option.optionName,
+                optionHash: option.optionHash
+            })),
+            pollContentType: WAProto.Message.PollContentType.IMAGE,
+            endTime: imagePoll.endDate ? imagePoll.endDate.getTime() : undefined,
+            hideParticipantName: imagePoll.hideVoter ?? false,
+            allowAddOption: imagePoll.canAddOption ?? false
+        };
+        m.messageContextInfo = {
+            messageSecret: imagePoll.messageSecret || randomBytes(32)
+        };
+    }
     else if (hasNonNullishProperty(message, 'poll')) {
         (_a = message.poll).selectableCount || (_a.selectableCount = 0);
         (_b = message.poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
@@ -1550,6 +1592,10 @@ export const generateWAMessageContent = async (message, options) => {
     if (hasOptionalProperty(message, 'groupStatus') && !!message.groupStatus) {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
+        const privateAudience = message.private;
+        if (privateAudience !== undefined && (privateAudience === null || typeof privateAudience !== 'object' || Array.isArray(privateAudience))) {
+            throw new Boom('groupStatus private metadata must be an object', { statusCode: 400 });
+        }
         if (key && 'contextInfo' in key && !!key.contextInfo) {
             key.contextInfo.isGroupStatus = message.groupStatus;
         }
@@ -1558,8 +1604,32 @@ export const generateWAMessageContent = async (message, options) => {
                 isGroupStatus: message.groupStatus
             };
         }
-        m = { groupStatusMessageV2: { message: m } };
+        if (privateAudience && (privateAudience.name != null || privateAudience.emoji != null)) {
+            const name = privateAudience.name == null ? '' : String(privateAudience.name);
+            const emoji = privateAudience.emoji == null ? '' : String(privateAudience.emoji);
+            if (!name && !emoji) {
+                throw new Boom('groupStatus private metadata requires a name or emoji', { statusCode: 400 });
+            }
+            const statusMessage = m[Object.keys(m)[0]];
+            statusMessage.contextInfo = {
+                ...(statusMessage.contextInfo || {}),
+                statusAudienceMetadata: {
+                    audienceType: proto.ContextInfo.StatusAudienceMetadata.AudienceType.CLOSE_FRIENDS,
+                    ...(name ? { listName: name } : {}),
+                    ...(emoji ? { listEmoji: emoji } : {})
+                }
+            };
+        }
+        // V2 remains the default. The legacy envelope is available for
+        // compatibility testing with clients that still handle the two
+        // group-status fields differently.
+        const groupStatusVersion = message.groupStatusVersion || options?.groupStatusVersion;
+        m = groupStatusVersion === 'legacy' || groupStatusVersion === 'v1'
+            ? { groupStatusMessage: { message: m } }
+            : { groupStatusMessageV2: { message: m } };
         delete message.groupStatus;
+        delete message.groupStatusVersion;
+        delete message.private;
     }
     // Media spoiler support uses WhatsApp's FutureProofMessage spoiler envelope plus
     // contextInfo.isSpoiler. Text spoilers use ||...|| by default because native text
@@ -1790,6 +1860,91 @@ export const generateWAMessage = async (jid, content, options) => {
     }
     return generateWAMessageFromContent(jid, await generateWAMessageContent(content, options), options);
 };
+/**
+ * Hashes an image-poll option as SHA-256(SHA-256(option name) + base64(file SHA-256)).
+ * This follows the WhatsApp Web image-poll format; the format remains experimental.
+ */
+export const hashImagePollOption = (optionName, fileSha256) => {
+    const nameHash = sha256(Buffer.from(String(optionName), 'utf-8')).toString('hex');
+    const mediaHash = fileSha256 ? Buffer.from(fileSha256).toString('base64') : '';
+    return sha256(Buffer.from(nameHash + mediaHash, 'utf-8')).toString('hex');
+};
+/**
+ * Sends a photo poll as one poll-creation message followed by associated image child messages.
+ * `relay` receives `(message, relayOptions, webMessageInfo)` for each wire message.
+ */
+export const generateWAMessageFromImagePoll = async (jid, content, relay, options = {}) => {
+    if (typeof relay !== 'function') {
+        throw new Boom('image poll requires a relay callback', { statusCode: 400 });
+    }
+    if (!Array.isArray(content?.values) || content.values.length < 2 || content.values.length > 12) {
+        throw new Boom('image poll requires between 2 and 12 values', { statusCode: 400 });
+    }
+    if (content.values.some(value => value && typeof value === 'object' && value.image) && typeof options.upload !== 'function') {
+        throw new Boom('image poll requires a configured media uploader', { statusCode: 400 });
+    }
+    const prepared = [];
+    const pollOptions = [];
+    for (const value of content.values) {
+        const option = typeof value === 'string' ? { name: value } : value;
+        const optionName = option?.name ?? option?.optionName;
+        if (typeof optionName !== 'string' || !optionName.trim()) {
+            throw new Boom('Each image poll value must have a non-empty name', { statusCode: 400 });
+        }
+        let media;
+        if (option.image) {
+            media = await prepareWAMessageMedia({ image: option.image }, { ...options, jid });
+        }
+        prepared.push({ media });
+        pollOptions.push({
+            optionName,
+            optionHash: hashImagePollOption(optionName, media?.imageMessage?.fileSha256)
+        });
+    }
+    if (!prepared.some(({ media }) => media)) {
+        throw new Boom('At least one image poll option must include an image', { statusCode: 400 });
+    }
+    const pollMessageContent = await generateWAMessageContent({
+        imagePoll: {
+            name: content.name,
+            selectableCount: content.selectableCount ?? 1,
+            options: pollOptions,
+            endDate: content.endDate,
+            hideVoter: content.hideVoter,
+            canAddOption: content.canAddOption,
+            messageSecret: content.messageSecret
+        }
+    }, { ...options, jid });
+    const poll = generateWAMessageFromContent(jid, pollMessageContent, { ...options, jid });
+    const pollMeta = {
+        tag: 'meta',
+        attrs: {
+            polltype: 'creation',
+            contenttype: isJidNewsletter(jid) ? 'image' : undefined
+        },
+        content: undefined
+    };
+    await relay(poll.message, {
+        messageId: poll.key.id,
+        additionalNodes: [...(options.additionalNodes || []), pollMeta]
+    }, poll);
+    for (let index = 0; index < prepared.length; index++) {
+        const media = prepared[index].media;
+        if (!media) continue;
+        const optionMessage = proto.Message.fromObject({
+            pollCreationOptionImageMessage: { message: media },
+            messageContextInfo: {
+                messageAssociation: {
+                    associationType: proto.MessageAssociation.AssociationType.MEDIA_POLL,
+                    parentMessageKey: poll.key
+                }
+            }
+        });
+        const option = generateWAMessageFromContent(jid, optionMessage, { ...options, jid, messageId: undefined });
+        await relay(option.message, { messageId: option.key.id }, option);
+    }
+    return poll;
+};
 /** Get the key to access the true type of content */
 export const getContentType = (content) => {
     if (content) {

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

@@ -47,8 +47,16 @@ export const tokenizeCode = (code, language = 'javascript') => {
 };
 const firstImageValue = (...values) => values.find(value => value !== undefined && value !== null && String(value).length > 0);
 
+const inferImageMimeType = (url = '') => {
+    const path = String(url).split('?')[0].toLowerCase();
+    if (path.endsWith('.jpg') || path.endsWith('.jpeg')) return 'image/jpeg';
+    if (path.endsWith('.webp')) return 'image/webp';
+    if (path.endsWith('.gif')) return 'image/gif';
+    return 'image/png';
+};
+
 /** Normalize album image variants without downgrading full-size URLs to previews. */
-const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000), { fullOnly = false } = {}) => {
+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);
@@ -59,13 +67,7 @@ const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30
     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 || (() => {
-        const value = String(fullUrl || previewUrl).split('?')[0].toLowerCase();
-        if (value.endsWith('.jpg') || value.endsWith('.jpeg')) return 'image/jpeg';
-        if (value.endsWith('.webp')) return 'image/webp';
-        if (value.endsWith('.gif')) return 'image/gif';
-        return 'image/png';
-    })();
+    const mimeType = image.mimeType || image.mime_type || inferImageMimeType(fullUrl || previewUrl);
     const media = (url, mediaWidth, mediaHeight) => ({
         url,
         url_fallback: url,
@@ -79,11 +81,11 @@ const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30
         asset_query_status: 'FETCHED',
         __typename: 'GenAIImagePrimitive'
     };
-    if (!fullOnly) {
-        primitive.preview_image = media(previewUrl, width, height);
-        primitive.dark_mode_preview_image = media(darkPreviewUrl, darkWidth, darkHeight);
-        primitive.dark_mode_full_image = media(darkFullUrl, darkWidth, darkHeight);
-    }
+    // WhatsApp requires the preview slots to recognize an image primitive.
+    // Omitting them makes mixed image/video albums silently drop the image.
+    primitive.preview_image = media(previewUrl, width, height);
+    primitive.dark_mode_preview_image = media(darkPreviewUrl, darkWidth, darkHeight);
+    primitive.dark_mode_full_image = media(darkFullUrl, darkWidth, darkHeight);
     return primitive;
 };
 // Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
@@ -138,8 +140,24 @@ export const toUnified = (submessages, uuid) => ({
             }
             case RichSubMessageType.INLINE_IMAGE: {
                 const image = submessage.imageMetadata || {};
-                const media = mediaPrimitive({ url: image.imageUrl || image.url, mime_type: image.mimeType || image.mime_type, width: image.width, height: image.height });
-                return media ? { view_model: { primitive: media, __typename: 'GenAISingleLayoutViewModel' } } : {};
+                const rawImage = image.imageUrl || image.url || image.image;
+                const imageData = typeof rawImage === 'string'
+                    ? { ...image, url: rawImage }
+                    : { ...image, ...(rawImage || {}) };
+                const primitive = buildRichImagePrimitive({
+                    ...imageData,
+                    mimeType: imageData.mimeType || imageData.mime_type,
+                });
+                return primitive.full_image.url
+                    ? {
+                        view_model: {
+                            primitives: [{ ...primitive, display_mode: 'FULL_WIDTH', full_width: true }],
+                            display_mode: 'FULL_WIDTH',
+                            full_width: true,
+                            __typename: 'GenAIVStackLayoutViewModel'
+                        }
+                    }
+                    : {};
             }
             case RichSubMessageType.LATEX: {
                 const metadata = submessage.latexMetadata || {};
@@ -842,23 +860,20 @@ export const prepareRichQuoteMessage = (options = {}) => {
  * @returns {Object} Wrapped botForwardedMessage ready for relayMessage
  */
 export const prepareRichImageMessage = (options = {}) => {
-    const { url = '', mimeType = 'image/png', verificationMetadata } = options;
-    const media = {
-        __typename: 'GenAIMediaItem',
-        mime_type: mimeType,
-        url,
-        url_fallback: url,
+    const { url = '', mimeType, verificationMetadata } = options;
+    const primitive = {
+        ...buildRichImagePrimitive({ url, mimeType }),
+        display_mode: 'FULL_WIDTH',
+        full_width: true,
     };
     const sections = [
         {
             __typename: 'GenAIUnifiedResponseSection',
             view_model: {
-                __typename: 'GenAISingleLayoutViewModel',
-                primitive: {
-                    __typename: 'GenAIImagePrimitive',
-                    preview_image: media,
-                    full_image: media,
-                },
+                __typename: 'GenAIVStackLayoutViewModel',
+                primitives: [primitive],
+                display_mode: 'FULL_WIDTH',
+                full_width: true,
             },
         },
     ];
@@ -1009,7 +1024,7 @@ export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata }
             fullUrl,
             ...(fullWidth > 0 ? { width: fullWidth, fullWidth } : {}),
             ...(fullHeight > 0 ? { height: fullHeight, fullHeight } : {})
-        }, expiration, { fullOnly: true });
+        }, expiration);
         return { ...primitive, display_mode: 'FULL_WIDTH', full_width: true };
     });
     const richResponseMessage = proto.AIRichResponseMessage.create({
@@ -1320,8 +1335,61 @@ export const prepareBotPttTranscriptMessage = ({ text = '', transcript = '', ver
     return envelope;
 };
 
+const buildFoaHtmlSection = (html, trustedSources = []) => ({
+    __typename: 'GenAIUnifiedResponseSection',
+    view_model: {
+        __typename: 'GenAISingleLayoutViewModel',
+        primitive: {
+            __typename: 'FOAHtmlPrimitiveDemoDONOTUSE',
+            trusted_sources: Array.isArray(trustedSources) ? trustedSources : [],
+            payload: String(html ?? '').trim()
+        }
+    }
+});
+
+const buildRichHtmlScreen = (options = {}) => {
+    const {
+        html = '',
+        trustedSources = [],
+        url = '',
+        title = 'Preview',
+        tabHeader = 'HTML',
+        tabs
+    } = options;
+    const tabItems = Array.isArray(tabs) && tabs.length
+        ? tabs
+        : [{ id: 'tab_0', tab_header: tabHeader, html }];
+    const embeddedTabs = tabItems.map((tab, index) => ({
+        id: tab.id || `tab_${index}`,
+        tab_header: tab.tab_header || tab.title || `HTML ${index + 1}`,
+        sections: [{
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAISingleLayoutViewModel',
+                primitive: {
+                    __typename: 'GenAIaeacdsnwHtmlPrimitive',
+                    payload: String(tab.html ?? tab.payload ?? html).trim(),
+                    url: tab.url || url,
+                    trusted_sources: tab.trustedSources || trustedSources
+                }
+            }
+        }],
+        step_entries: []
+    }));
+    return {
+        title,
+        embeddedScreen: {
+            title,
+            content: [{
+                __typename: 'FOAIDNixelButtonSheets',
+                tabs: embeddedTabs
+            }]
+        }
+    };
+};
+
 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;
+    const { alignment, code, contentText, disclaimerText, footerText, headerText, html, richHtml, trustedSources, imageText, inlineImage, inlineVideo, items, language, latex, links, noDonation, noHeading, posts, products, reels, sources: sourceInputs, suggested, richResponse, table, tapLinkUrl, title, verificationMetadata, sections: rawSections, richSections, copyButton, copyToClipboard, copyText, copyLabel, richText, quote, richImage, richLinks, richMap, map, dynamicMedia, richDynamicMedia, socialEntity, socialProfile, richMenu, airichCommandMenu, unifiedResponse, gridImages, verticalAlbum, videoGrid, richGeneration, richLabel, suggestedPrompt, botSources, botPttTranscript } = content;
     let submessages = [];
     const extraSections = [];
     if (Array.isArray(richResponse)) {
@@ -1456,19 +1524,25 @@ export const prepareRichResponseMessage = (content) => {
             });
         }
         if (inlineImage) {
+            const image = typeof inlineImage === 'string' ? { url: inlineImage } : (inlineImage || {});
             submessages.push({
                 messageType: RichSubMessageType.INLINE_IMAGE,
                 imageMetadata: {
-                    imageUrl: inlineImage,
+                    ...image,
+                    imageUrl: image.url || image.imageUrl || image.image || '',
                     imageText,
                     alignment,
-                    tapLinkUrl
+                    tapLinkUrl,
+                    mimeType: image.mimeType || image.mime_type,
+                    width: image.width,
+                    height: image.height,
+                    fullWidth: image.fullWidth || image.full_width,
+                    fullHeight: image.fullHeight || image.full_height
                 }
             });
         }
         if (inlineVideo) {
             const video = typeof inlineVideo === 'string' ? { url: inlineVideo } : inlineVideo;
-            submessages.push({ messageType: RichSubMessageType.TEXT, messageText: '[ CANNOT_LOAD_VIDEO - NIXEL ]' });
             extraSections.push({
                 view_model: {
                     primitive: buildImaginePrimitive({
@@ -1565,10 +1639,6 @@ export const prepareRichResponseMessage = (content) => {
             });
         }
         if (posts) {
-            submessages.push({
-                messageType: RichSubMessageType.TEXT,
-                messageText: '[ CANNOT_LOAD_POST - NIXEL ]'
-            });
             const postItems = (Array.isArray(posts) ? posts : [posts]).map((post) => ({
                 title: post?.title || '',
                 subtitle: post?.subtitle || '',
@@ -1593,10 +1663,6 @@ export const prepareRichResponseMessage = (content) => {
             if (postItems.length) extraSections.push({ view_model: { primitives: postItems, __typename: 'GenAIHScrollLayoutViewModel' } });
         }
         if (products) {
-            submessages.push({
-                messageType: RichSubMessageType.TEXT,
-                messageText: '[ CANNOT_LOAD_PRODUCT - NIXEL ]'
-            });
             const productItems = (Array.isArray(products) ? products : [products]).map((product) => ({
                 title: product?.title || '',
                 brand: product?.brand || '',
@@ -1640,11 +1706,72 @@ export const prepareRichResponseMessage = (content) => {
             });
         }
     }
+    const htmlIsTabbedConfig = html && typeof html === 'object' && Array.isArray(html.tabs);
+    const simpleHtmlPayload = htmlIsTabbedConfig ? '' : (typeof html === 'string' ? html : (html?.html ?? html?.payload ?? ''));
+    const htmlPayload = simpleHtmlPayload;
+    const htmlTrustedSources = Array.isArray(html?.trustedSources) ? html.trustedSources : trustedSources;
+    if (String(htmlPayload).trim()) {
+        extraSections.push(buildFoaHtmlSection(htmlPayload, htmlTrustedSources));
+    }
+    const richHtmlOptions = richHtml ?? (htmlIsTabbedConfig ? html : null);
+    const richHtmlConfig = typeof richHtmlOptions === 'string'
+        ? { html: richHtmlOptions, trustedSources }
+        : (richHtmlOptions && typeof richHtmlOptions === 'object'
+            ? { ...richHtmlOptions, trustedSources: richHtmlOptions.trustedSources ?? trustedSources }
+            : null);
+    const hasRichHtmlContent = !!(richHtmlConfig && (
+        String(richHtmlConfig.html || '').trim() ||
+        (Array.isArray(richHtmlConfig.tabs) && richHtmlConfig.tabs.some(tab => String(tab?.html ?? tab?.payload ?? '').trim()))
+    ));
+    let richHtmlScreen;
+    if (hasRichHtmlContent) {
+        richHtmlScreen = buildRichHtmlScreen(richHtmlConfig);
+        submessages.unshift({
+            messageType: RichSubMessageType.TEXT,
+            messageText: `> ${richHtmlScreen.title}`
+        });
+    }
     const uuid = randomUUID();
     const unified = toUnified(submessages, uuid);
     unified.sections = [...unified.sections.filter(Boolean), ...extraSections];
+    if (richHtmlScreen) unified.embedded_screens = [richHtmlScreen.embeddedScreen];
+
+    // Compose the remaining AIRich convenience formats as sections. These
+    // aliases intentionally mirror the standalone send* helpers, allowing a
+    // caller to mix them with text, HTML, tables, media, and citations in one
+    // PLOGME message. Raw sections remain available as the forward-compatible
+    // escape hatch for new WhatsApp primitives.
+    const composed = { sections: unified.sections, embedded_screens: unified.embedded_screens, submessages, botMetadata: {} };
+    const append = (prepared) => appendPreparedRichContent(composed, prepared);
+    if (copyButton || copyToClipboard || copyText) append(prepareCopyToClipboardMessage(copyButton || copyToClipboard || { text: copyText, label: copyLabel }));
+    if (richText) append(prepareRichTextMessage(typeof richText === 'string' ? { text: richText } : richText));
+    if (quote) append(prepareRichQuoteMessage(typeof quote === 'string' ? { text: quote } : quote));
+    if (richImage) append(prepareRichImageMessage(typeof richImage === 'string' ? { url: richImage } : richImage));
+    if (richLinks) append(prepareRichLinkMessage(Array.isArray(richLinks) ? { links: richLinks } : richLinks));
+    if (richMap || map) append(prepareRichMapMessage(richMap || map));
+    if (dynamicMedia || richDynamicMedia) append(prepareRichDynamicMediaMessage(dynamicMedia || richDynamicMedia));
+    if (socialEntity) append(prepareSocialEntityMessage(socialEntity));
+    if (socialProfile) append(prepareSocialProfileMessage(socialProfile));
+    if (richMenu) append(prepareRichMenuMessage(richMenu));
+    if (airichCommandMenu) append(prepareAIRichCommandMenu(airichCommandMenu));
+    if (gridImages) append(prepareGridImageMessage({ imageUrls: gridImages, verificationMetadata }));
+    if (verticalAlbum) append(prepareVerticalAlbumMessage({ items: verticalAlbum, verificationMetadata }));
+    if (videoGrid) append(prepareVideoGridMessage({ videos: videoGrid, verificationMetadata }));
+    if (richGeneration) append(prepareRichGenerationMessage({ ...richGeneration, verificationMetadata }));
+    if (richLabel) append(buildRichLabelMessage(richLabel));
+    if (suggestedPrompt) append(prepareBotPromptSuggestionsMessage({ ...suggestedPrompt, verificationMetadata }));
+    if (botSources) append(prepareBotSourcesMessage({ ...botSources, verificationMetadata }));
+    if (botPttTranscript) append(prepareBotPttTranscriptMessage({ ...botPttTranscript, verificationMetadata }));
+    if (unifiedResponse?.sections) {
+        unified.sections.push(...unifiedResponse.sections);
+        if (Array.isArray(unifiedResponse.embedded_screens)) unified.embedded_screens = [...(unified.embedded_screens || []), ...unifiedResponse.embedded_screens];
+    }
+    for (const section of [...(Array.isArray(rawSections) ? rawSections : []), ...(Array.isArray(richSections) ? richSections : [])]) {
+        if (section && typeof section === 'object') unified.sections.push(section);
+    }
+    if (composed.embedded_screens?.length) unified.embedded_screens = composed.embedded_screens;
     const richResponseMessage = proto.AIRichResponseMessage.create({
-        submessages,
+        submessages: composed.submessages,
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
         unifiedResponse: {
             data: Buffer.from(JSON.stringify(unified)) // Lia@Note 25-04-26 --- Expects "ArrayBufferLike"
@@ -1658,6 +1785,7 @@ export const prepareRichResponseMessage = (content) => {
     });
     const message = wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
     const botMetadata = message.messageContextInfo.botMetadata;
+    Object.assign(botMetadata, composed.botMetadata);
     // Lia@Note 13-05-26 --- Add disclaimer text on richResponseMessage
     if (disclaimerText) {
         botMetadata.messageDisclaimerText = disclaimerText;
@@ -1706,19 +1834,7 @@ export const botMetadataCertificate = (length = 685) => {
  */
 export const prepareHtmlMessage = (options = {}) => {
     const { html = '', trustedSources = [], verificationMetadata } = options;
-    const sections = [
-        {
-            __typename: 'GenAIUnifiedResponseSection',
-            view_model: {
-                __typename: 'GenAISingleLayoutViewModel',
-                primitive: {
-                    __typename: 'FOAHtmlPrimitiveDemoDONOTUSE',
-                    trusted_sources: trustedSources,
-                    payload: String(html).trim()
-                }
-            }
-        }
-    ];
+    const sections = [buildFoaHtmlSection(html, trustedSources)];
     const unified = { response_id: randomUUID(), sections };
     const richResponseMessage = proto.AIRichResponseMessage.create({
         submessages: [],
@@ -1735,35 +1851,8 @@ export const prepareHtmlMessage = (options = {}) => {
  * aeacdsnw HTML primitive used by the attached game message.
  */
 export const prepareRichHtmlMessage = (options = {}) => {
-    const {
-        html = '',
-        trustedSources = [],
-        url = '',
-        title = 'Preview',
-        tabHeader = 'HTML',
-        tabs,
-        verificationMetadata
-    } = options;
-    const tabItems = Array.isArray(tabs) && tabs.length
-        ? tabs
-        : [{ id: 'tab_0', tab_header: tabHeader, html }];
-    const embeddedTabs = tabItems.map((tab, index) => ({
-        id: tab.id || `tab_${index}`,
-        tab_header: tab.tab_header || tab.title || `HTML ${index + 1}`,
-        sections: [{
-            __typename: 'GenAIUnifiedResponseSection',
-            view_model: {
-                __typename: 'GenAISingleLayoutViewModel',
-                primitive: {
-                    __typename: 'GenAIaeacdsnwHtmlPrimitive',
-                    payload: String(tab.html ?? tab.payload ?? html).trim(),
-                    url: tab.url || url,
-                    trusted_sources: tab.trustedSources || trustedSources
-                }
-            }
-        }],
-        step_entries: []
-    }));
+    const { verificationMetadata } = options;
+    const { title, embeddedScreen } = buildRichHtmlScreen(options);
     const unified = {
         response_id: randomUUID(),
         sections: [{
@@ -1772,13 +1861,7 @@ export const prepareRichHtmlMessage = (options = {}) => {
                 __typename: 'GenAISingleLayoutViewModel'
             }
         }],
-        embedded_screens: [{
-            title,
-            content: [{
-                __typename: 'FOAIDNixelButtonSheets',
-                tabs: embeddedTabs
-            }]
-        }]
+        embedded_screens: [embeddedScreen]
     };
     const richResponseMessage = proto.AIRichResponseMessage.create({
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
@@ -1789,6 +1872,35 @@ export const prepareRichHtmlMessage = (options = {}) => {
     return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
 };
 
+const decodePreparedUnified = (prepared) => {
+    const richResponse = prepared?.botForwardedMessage?.message?.richResponseMessage;
+    const rawData = richResponse?.unifiedResponse?.data;
+    if (!rawData) return null;
+    try {
+        const text = Buffer.isBuffer(rawData)
+            ? rawData.toString()
+            : (rawData instanceof Uint8Array ? Buffer.from(rawData).toString() : String(rawData));
+        const decoded = Buffer.from(text, /^[A-Za-z0-9+/]+=*$/.test(text) ? 'base64' : 'utf8').toString();
+        return JSON.parse(decoded);
+    }
+    catch {
+        return null;
+    }
+};
+
+/** Merge any prepared AIRich helper into a single PLOGME response. */
+const appendPreparedRichContent = (target, prepared) => {
+    const unified = decodePreparedUnified(prepared);
+    if (unified?.sections?.length) target.sections.push(...unified.sections);
+    if (Array.isArray(unified?.embedded_screens)) {
+        target.embedded_screens = [...(target.embedded_screens || []), ...unified.embedded_screens];
+    }
+    const richResponse = prepared?.botForwardedMessage?.message?.richResponseMessage;
+    if (Array.isArray(richResponse?.submessages)) target.submessages.push(...richResponse.submessages);
+    const botMetadata = prepared?.messageContextInfo?.botMetadata;
+    if (botMetadata) Object.assign(target.botMetadata, botMetadata);
+};
+
 /**
  * Proofs are forwarded only when the caller supplies real, verifiable proofs.
  * The library never fabricates a certificate chain or signature: an unverifiable

package/lib/index.d.ts

@@ -50,6 +50,8 @@ export interface StatusContent {
 
 export interface GroupStatusContent extends StatusContent {
     groupStatus: true;
+    /** Select the legacy groupStatusMessage envelope for compatibility testing. */
+    groupStatusVersion?: 'legacy' | 'v1' | 'v2';
 }
 
 /** One status distribution list entry as returned by `getStatusPrivacy`. */
@@ -466,6 +468,8 @@ export interface WASocket {
     sendBotToolResult(jid: string, content?: { text?: string; toolCallId?: string; resolutionData?: unknown; resolutionDataSerialized?: string; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send one tolerant AIRich response containing every supported section supplied in content. */
     sendPlogmeMessage(jid: string, content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a native group status with optional private named-audience metadata. */
+    sendGroupStatus(jid: string, content: Record<string, unknown>, options?: { private?: { name?: string; emoji?: string }; [key: string]: unknown }): Promise<unknown>;
     /** Send a compact forwarded AIRich label bubble with optional colors and variant. */
     sendRichLabelMessage(jid: string, content?: { text?: string; variant?: string; backgroundColor?: string; textColor?: string; responseId?: string }, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
     /** Send a prompt through the verified Meta AI/Hatch route and return its message ID. */

package/package.json

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