plogme 2.0.7 → 2.0.9

package/lib/Utils/meta-ai-msmsg.js

@@ -65,10 +65,10 @@ const decodeDecryptedMsmsgMessage = (decrypted) => {
         const unpadded = Buffer.from(unpadRandomMax16(buf));
         const decoded = proto.Message.decode(unpadded);
         const hasContent = Object.keys(decoded).some(k => k !== 'messageContextInfo' && decoded[k] != null);
-        if (hasContent) return decoded;
+        if (hasContent) return decodeUnifiedResponseInPlace(decoded);
     }
     catch {}
-    return proto.Message.decode(buf);
+    return decodeUnifiedResponseInPlace(proto.Message.decode(buf));
 };
 
 /**
@@ -127,4 +127,77 @@ export const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) =
     throw err;
 };
 
+// unifiedResponse.data is base64/bytes-wrapped JSON, not encrypted. Keep the
+// original data and expose both the decoded object and flattened text.
+export const parseUnifiedResponseData = (data) => {
+    if (!data)
+        return null;
+    try {
+        let buf;
+        if (Buffer.isBuffer(data))
+            buf = data;
+        else if (data instanceof Uint8Array)
+            buf = Buffer.from(data);
+        else if (typeof data === 'string')
+            buf = Buffer.from(data, 'base64');
+        else if (data.type === 'Buffer' && Array.isArray(data.data))
+            buf = Buffer.from(data.data);
+        else
+            return null;
+        return JSON.parse(buf.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+};
+export const textFromUnifiedResponse = (data) => {
+    const json = parseUnifiedResponseData(data);
+    if (!json)
+        return null;
+    const parts = [];
+    for (const section of json.sections || []) {
+        const text = section?.view_model?.primitive?.text;
+        if (text)
+            parts.push(text);
+    }
+    return parts.length ? parts.join('\n') : null;
+};
+export const textFromRichResponse = (richResponse) => {
+    if (!richResponse)
+        return null;
+    if (Array.isArray(richResponse.submessages)) {
+        const parts = richResponse.submessages
+            .map(submessage => submessage?.messageText)
+            .filter(text => typeof text === 'string' && text.length);
+        if (parts.length)
+            return parts.join('\n');
+    }
+    return textFromUnifiedResponse(richResponse.unifiedResponse?.data);
+};
+export const extractMetaAiText = (message) => {
+    if (!message)
+        return null;
+    const body = message.protocolMessage?.editedMessage || message;
+    return body.extendedTextMessage?.text ?? body.conversation ?? textFromRichResponse(body.richResponseMessage) ?? null;
+};
+export const decodeUnifiedResponseInPlace = (message) => {
+    if (!message || typeof message !== 'object')
+        return message;
+    const bodies = [
+        message,
+        message.protocolMessage?.editedMessage,
+        message.editedMessage
+    ].filter(Boolean);
+    for (const body of bodies) {
+        const unifiedResponse = body.richResponseMessage?.unifiedResponse;
+        if (unifiedResponse && unifiedResponse.data != null && unifiedResponse.decodedData === undefined) {
+            unifiedResponse.decodedData = parseUnifiedResponseData(unifiedResponse.data);
+            const text = textFromUnifiedResponse(unifiedResponse.data);
+            if (text != null)
+                unifiedResponse.text = text;
+        }
+    }
+    return message;
+};
+
 export { decodeDecryptedMsmsgMessage };

package/lib/Utils/meta-compositing.js

@@ -7,7 +7,7 @@
  *   - Plain text fallback is used unless the native payload can be authenticated
  *
  * metaTyping() — shows the "typing..." / planning steps indicator.
- * sendMetaComposited() — full flow: typing → delete → final message.
+ * sendMetaComposited() — full flow: initial message → streaming MESSAGE_EDIT frames → final edit.
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
  */
@@ -161,12 +161,21 @@ export const metaTyping = async (sock, jid, {
     return sock.sendMessage(jid, placeholder);
 };
 
+/** Send a streaming MESSAGE_EDIT frame without changing the original key. */
+export const editMetaMessage = async (sock, jid, key, content, sendOptions = {}, streamContext) => {
+    if (!key)
+        return undefined;
+    const frame = streamContext
+        ? { ...content, messageContextInfo: { ...streamContext, ...content.messageContextInfo } }
+        : content;
+    return sock.sendMessage(jid, { ...frame, edit: key }, sendOptions);
+};
+
 /**
- * sendMetaComposited — full Meta AI flow (UNIVERSAL).
- *   1. Send progress indicator
- *   2. Wait thinkingMs
- *   3. Delete placeholder
- *   4. Send final message fresh
+ * sendMetaComposited — full Meta AI-style flow (UNIVERSAL).
+ *   1. Send initial progress indicator
+ *   2. Optionally emit streamUpdates as MESSAGE_EDIT frames
+ *   3. Edit the same message into the final response
  */
 export const sendMetaComposited = async (sock, jid, content, {
     thinkingMs = 2000,
@@ -174,7 +183,10 @@ export const sendMetaComposited = async (sock, jid, content, {
     steps = [],
     placeholderText = '',
     sendOptions = {},
-    useNativeMeta = false
+    useNativeMeta = false,
+    streamUpdates = [],
+    streamUpdateDelayMs = 0,
+    streamContext
 } = {}) => {
     const placeholder = await metaTyping(sock, jid, {
         description, steps, estimatedMs: thinkingMs, placeholderText, useNativeMeta
@@ -183,12 +195,29 @@ export const sendMetaComposited = async (sock, jid, content, {
     try {
         await delay(thinkingMs);
         if (placeholder?.key) {
-            await sock.sendMessage(jid, { delete: placeholder.key });
+            for (const update of streamUpdates) {
+                const frame = typeof update === 'string' ? { text: update } : update;
+                try {
+                    await editMetaMessage(sock, jid, placeholder.key, frame, sendOptions, streamContext);
+                }
+                catch (_) {}
+                if (streamUpdateDelayMs > 0)
+                    await delay(streamUpdateDelayMs);
+            }
+            try {
+                await editMetaMessage(sock, jid, placeholder.key, content, sendOptions, streamContext);
+            }
+            catch (_) {
+                await sock.sendMessage(jid, content, sendOptions);
+            }
+        }
+        else {
+            await sock.sendMessage(jid, content, sendOptions);
         }
     } catch (_) {}
 
     await sock.sendPresenceUpdate('paused', jid);
-    return sock.sendMessage(jid, content, sendOptions);
+    return placeholder;
 };
 
 /**

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

@@ -48,7 +48,7 @@ export const tokenizeCode = (code, language = 'javascript') => {
 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 buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000), { fullOnly = false } = {}) => {
     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,7 +59,13 @@ 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 || 'image/png';
+    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 media = (url, mediaWidth, mediaHeight) => ({
         url,
         url_fallback: url,
@@ -68,14 +74,17 @@ const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30
         width: mediaWidth,
         height: mediaHeight
     });
-    return {
-        preview_image: media(previewUrl, width, height),
+    const primitive = {
         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'
     };
+    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);
+    }
+    return primitive;
 };
 // 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) => ({
@@ -974,13 +983,33 @@ export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata }
             if (!url) throw new Error('Each video album item requires a video URL');
             return buildImaginePrimitive({ mediaType: 'video', url, thumbnail: video?.thumbnail || video?.thumbnailUrl, mimeType: video?.mimeType || video?.mime_type || 'video/mp4', fileLength: video?.fileLength || video?.file_length || 0, duration: video?.duration || 0, status: 'READY' });
         }
-        const image = item?.image || item?.data || item;
-        const sourceUrl = typeof image === 'string' ? image : firstImageValue(
+        const rawImage = item?.image || item?.data || item;
+        const image = typeof rawImage === 'string' ? { url: rawImage } : (rawImage || {});
+        const sourceUrl = 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 primitive = buildRichImagePrimitive({ ...image, width: image?.width || item?.width, height: image?.height || item?.height }, expiration);
+        // Unlike a compact image grid, vertical albums are intended to render
+        // the actual media at full size. Some clients choose preview_image and
+        // never follow full_image, so expose the selected full URL/dimensions
+        // in both slots instead of allowing a thumbnail URL to win.
+        const fullUrl = firstImageValue(
+            image?.imageHighResUrl, image?.highResUrl, image?.high_res_url,
+            image?.fullUrl, image?.full_url, image?.sourceUrl, image?.source_url, image?.url
+        ) || sourceUrl;
+        const fullWidth = Number(image?.fullWidth || image?.full_width || image?.highResWidth || image?.high_res_width || image?.width || item?.width || 0);
+        const fullHeight = Number(image?.fullHeight || image?.full_height || image?.highResHeight || image?.high_res_height || image?.height || item?.height || 0);
+        const primitive = buildRichImagePrimitive({
+            ...image,
+            imagePreviewUrl: fullUrl,
+            previewUrl: fullUrl,
+            sourceUrl: fullUrl,
+            imageHighResUrl: fullUrl,
+            fullUrl,
+            ...(fullWidth > 0 ? { width: fullWidth, fullWidth } : {}),
+            ...(fullHeight > 0 ? { height: fullHeight, fullHeight } : {})
+        }, expiration, { fullOnly: true });
         return { ...primitive, display_mode: 'FULL_WIDTH', full_width: true };
     });
     const richResponseMessage = proto.AIRichResponseMessage.create({
@@ -1152,11 +1181,13 @@ export const prepareUnifiedResponseMessage = ({ sections = [], submessages = [],
 };
 
 /** Build a protocol-backed AIRich map card with optional numbered annotations. */
-export const prepareRichMapMessage = ({ centerLatitude, centerLongitude, latitudeDelta, longitudeDelta, annotations = [], showInfoList = false, verificationMetadata } = {}) => {
+export const prepareRichMapMessage = ({ text = 'Map location', centerLatitude, centerLongitude, latitudeDelta, longitudeDelta, annotations = [], showInfoList = false, verificationMetadata } = {}) => {
     if (!Number.isFinite(Number(centerLatitude)) || !Number.isFinite(Number(centerLongitude))) {
         throw new Boom('prepareRichMapMessage requires centerLatitude and centerLongitude', { statusCode: 400 });
     }
-    const submessages = [{
+    const submessages = [
+        ...(text ? [{ messageType: RichSubMessageType.TEXT, messageText: String(text) }] : []),
+        {
         messageType: RichSubMessageType.MAP,
         mapMetadata: {
             centerLatitude: Number(centerLatitude),
@@ -1172,7 +1203,8 @@ export const prepareRichMapMessage = ({ centerLatitude, centerLongitude, latitud
                 body: String(annotation.body || '')
             }))
         }
-    }];
+        }
+    ];
     const richResponseMessage = proto.AIRichResponseMessage.create({
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
         submessages,
@@ -1205,9 +1237,36 @@ export const prepareBotSourcesMessage = ({ text = '', sources = [], verification
     if (!Array.isArray(sources) || sources.length === 0) {
         throw new Boom('prepareBotSourcesMessage requires at least one source', { statusCode: 400 });
     }
+    const submessages = [{
+        messageType: RichSubMessageType.TEXT,
+        messageText: String(text || 'Sources')
+    }];
+    const sourceCards = sources.map((source, index) => ({
+        source_type: 'THIRD_PARTY',
+        source_display_name: source.sourceTitle || source.title || '',
+        source_subtitle: source.sourceQuery || source.query || 'Source',
+        source_url: source.sourceProviderUrl || source.url || '',
+        favicon: {
+            url: source.faviconCdnUrl || source.faviconUrl || source.thumbnailCdnUrl || source.thumbnailUrl || '',
+            mime_type: 'image/jpeg',
+            width: 16,
+            height: 16
+        },
+        citation_number: source.citationNumber ?? index + 1
+    })).filter((source) => source.source_url || source.source_display_name);
+    const sections = toUnified(submessages, randomUUID()).sections;
+    if (sourceCards.length) {
+        sections.push({
+            view_model: {
+                primitive: { sources: sourceCards, __typename: 'GenAISearchResultPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
     const envelope = wrapToBotForwardedMessage(proto.AIRichResponseMessage.create({
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
-        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: String(text) }],
+        submessages,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: randomUUID(), sections })) },
         contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
     }), verificationMetadata);
     envelope.messageContextInfo.botMetadata.richResponseSourcesMetadata = {
@@ -1758,6 +1817,57 @@ export const attachBotVerificationProofs = (envelope, verificationMetadata) => {
     return envelope;
 };
 
+/**
+ * Build a forwarded AIRich label message.
+ *
+ * This is the small single-label surface used by WhatsApp clients for a
+ * colored forwarded bubble. The unified response is intentionally serialized
+ * as base64 text because that is the wire shape accepted by the raw
+ * `relayMessage` API.
+ */
+export const buildRichLabelMessage = ({
+    text = '',
+    variant = 'POSITIVE',
+    backgroundColor = '#FF0000FF',
+    textColor = '#000000FF',
+    responseId = randomUUID(),
+} = {}) => {
+    const unified = {
+        __typename: 'GenAIUnifiedResponse',
+        response_id: responseId,
+        sections: [{
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAISingleLayoutViewModel',
+                primitive: {
+                    __typename: 'GenAILabelPrimitive',
+                    text: String(text),
+                    variant,
+                    background_color_override: backgroundColor,
+                    text_color_override: textColor,
+                },
+            },
+        }],
+    };
+
+    return {
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: 1,
+                    unifiedResponse: {
+                        data: Buffer.from(JSON.stringify(unified)).toString('base64'),
+                    },
+                    contextInfo: {
+                        isForwarded: true,
+                        forwardOrigin: 4,
+                    },
+                },
+            },
+        },
+    };
+};
+
 /**
  * Wrap a rich response in the bot-forwarded envelope.
  *

package/lib/Utils/validate-connection.js

@@ -96,7 +96,9 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
             supportMessageAssociation: true,
             supportGroupHistory: false,
             onDemandReady: undefined,
-            supportGuestChat: undefined
+            supportGuestChat: undefined,
+            supportOmittedConversationIndex: true,
+            supportUniversalReachChat: true
         },
         version: {
             primary: 10,
@@ -203,4 +205,4 @@ export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
         account.accountSignatureKey = null;
     }
     return proto.ADVSignedDeviceIdentity.encode(account).finish();
-};
+};

package/lib/index.d.ts

@@ -132,6 +132,25 @@ export interface AIPromptOptions {
     /** Extra options forwarded to `sendMessage` (quoted, linkPreview, ...). */
     [key: string]: unknown;
 }
+/** Options for the verified Meta AI (Hatch) send path. */
+export interface MetaAISendOptions {
+    /** Destination JID; defaults to `867051314767696@bot` for a direct prompt. */
+    jid?: string;
+    invokerJid?: string;
+    sessionId?: string;
+    messageSecret?: Buffer;
+    capabilities?: number[];
+    /** F-BID used when invoking Meta AI in a group. */
+    botFbid?: string;
+    /** Add a visible Meta AI mention to a group prompt. */
+    mention?: boolean;
+    personaType?: string;
+    agentEngagementType?: string;
+    modeSelected?: string;
+    conversationContext?: Uint8Array | Buffer;
+    quoted?: unknown;
+    links?: unknown;
+}
 
 export interface RichMenuButton {
     id?: string;
@@ -351,6 +370,26 @@ export interface AIRichCommandMenuContent {
     footer?: string;
 }
 
+export declare function parseUnifiedResponseData(data: unknown): Record<string, unknown> | null;
+export declare function textFromUnifiedResponse(data: unknown): string | null;
+export declare function textFromRichResponse(message: unknown): string | null;
+export declare function extractMetaAiText(message: unknown): string | null;
+export declare function decodeUnifiedResponseInPlace<T extends Record<string, unknown>>(message: T): T;
+export interface MetaCompositedOptions {
+    thinkingMs?: number;
+    description?: string;
+    steps?: Array<Record<string, unknown>>;
+    estimatedMs?: number;
+    placeholderText?: string;
+    sendOptions?: Record<string, unknown>;
+    useNativeMeta?: boolean;
+    streamUpdates?: Array<string | Record<string, unknown>>;
+    streamUpdateDelayMs?: number;
+    streamContext?: Record<string, unknown>;
+}
+export declare function editMetaMessage(sock: WASocket, jid: string, key: WAMessageKey, content: Record<string, unknown>, sendOptions?: Record<string, unknown>, streamContext?: Record<string, unknown>): Promise<unknown>;
+export declare function sendMetaComposited(sock: WASocket, jid: string, content: Record<string, unknown>, options?: MetaCompositedOptions): Promise<unknown>;
+
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
     /** Send at least two image/video URL items as a full-width AIRich vertical album. */
@@ -427,6 +466,12 @@ 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 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. */
+    sendMetaAI(text: string, options?: MetaAISendOptions): Promise<string>;
+    /** Backward-compatible destination-first signature. */
+    sendMetaAI(jid: string, text: string, options?: Omit<MetaAISendOptions, 'jid'>): Promise<string>;
     /** Resolve a WhatsApp Channel invite code or invite URL to channel metadata. */
     newsletterGetInviteInfo(inviteCodeOrUrl: string): Promise<Record<string, unknown> | null>;
     /** React to a Channel post; pass an empty string, null, or undefined to remove the reaction. */

package/package.json

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