plogme 2.0.8 → 2.1.0

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

@@ -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'
     };
+    // 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)
 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);
         return { ...primitive, display_mode: 'FULL_WIDTH', full_width: true };
     });
     const richResponseMessage = proto.AIRichResponseMessage.create({
@@ -1788,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.8",
+  "version": "2.1.0",
   "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",