@crysnovax/baileys 2.6.1 → 2.6.2

package/README.md

@@ -118,7 +118,7 @@ const crysnova = {
 | Image Processing | ✅ | Auto-detects `sharp`, `@napi-rs/image`, or `jimp` |
 | Safe FFmpeg | ✅ | Uses `spawn` instead of `exec` |
 | In-Memory Store | ✅ | Reintroduced with minimal ESM adaptation |
-| HD Profile Picture | 🆕 | Full-size upload with no crop or resize via `{ hd: true }` |
+| HD Profile Picture | ✅ | Full-size upload with no crop or resize via `{ hd: true }` (max 720px) |
 
 ---
 
@@ -776,6 +776,10 @@ sock.sendMessage(jid, {
 
 ## Meta AI Features
 
+Meta AI-style thinking indicators and live reasoning feeds. Works on **all WhatsApp clients** — no "Update WhatsApp" messages.
+
+> **Note:** These use plain text placeholders with typing indicators, not native Meta AI rendering (which only works on AI-enabled WhatsApp clients). The visual experience is identical — users see "Thinking…" with live step completion.
+
 ### Meta Typing Indicator
 
 Show a live thinking indicator that you control. Delete it manually when ready — no "edited" badge ever appears.
@@ -797,6 +801,19 @@ await sock.sendMessage(jid, { delete: placeholder.key })
 await sock.sendMessage(jid, { text: 'Here is your answer!' })
 ```
 
+**What users see:**
+```
+[typing… indicator]
+
+_Thinking…_
+○ Reading your message…
+○ Writing response…
+
+[auto-deletes]
+
+Here is your answer!
+```
+
 ### Meta Compositing
 
 Full flow: indicator shows → auto-deletes → clean final message lands. Works with every rich content type.
@@ -875,6 +892,30 @@ await replayPlanning(
 )
 ```
 
+**What users see:**
+```
+_Thinking…_
+○ Understanding your question…
+○ Searching for data…
+○ Writing the answer…
+
+[step 1 completes]
+_Thinking…_
+✓ Understanding your question…
+○ Searching for data…
+○ Writing the answer…
+
+[step 2 completes]
+_Thinking…_
+✓ Understanding your question…
+✓ Searching for data…
+○ Writing the answer…
+
+[all done, deletes, then:]
+
+const answer = 42
+```
+
 **Step type helpers:**
 
 ```javascript
@@ -1344,7 +1385,9 @@ sock.updateProfilePicture(jid, { url })
 // Standard with custom dimensions
 sock.updateProfilePicture(jid, { url }, { width: 640, height: 640 })
 
-// 🆕 HD — full resolution, no crop, no resize
+// HD — preserves original aspect ratio, no crop, no padding
+// Images under 720px pass through unchanged.
+// Larger images are scaled down proportionally to fit within 720px.
 sock.updateProfilePicture(jid, buffer, { hd: true })
 sock.updateProfilePicture(jid, { url }, { hd: true })
 

package/lib/Socket/chats.js

@@ -5,7 +5,7 @@ import { DEFAULT_CACHE_TTLS, HISTORY_SYNC_PAUSED_TIMEOUT_MS, PROCESSABLE_HISTORY
 import { ALL_WA_PATCH_NAMES } from '../Types/index.js';
 import { SyncState } from '../Types/State.js';
 import { chatModificationToAppPatch, decodePatches, decodeSyncdSnapshot, encodeSyncdPatch, ensureLTHashStateVersion, extractSyncdPatches, generateProfilePicture, getHistoryMsg, isAppStateSyncIrrecoverable, isMissingKeyError, MAX_SYNC_ATTEMPTS, newLTHashState, processSyncAction } from '../Utils/index.js';
-import { getStream, toBuffer } from '../Utils/messages-media.js';
+import { generateProfilePictureHD } from '../Utils/messages-media.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import processMessage from '../Utils/process-message.js';
 import { buildTcTokenFromJid } from '../Utils/tc-token-utils.js';
@@ -228,18 +228,12 @@ export const makeChatsSocket = (config) => {
         else {
             targetJid = undefined;
         }
-        let img;
-        if (dimensions?.hd) {
-            // crysnovax@HD-Profile --- bypass resize/crop, send raw buffer directly
-            if (Buffer.isBuffer(content)) {
-                img = content;
-            } else {
-                const { stream } = await getStream(content);
-                img = await toBuffer(stream);
-            }
-        } else {
-            ({ img } = await generateProfilePicture(content, dimensions));
-        }
+        // crysnovax@HD-Profile --- Dual mode:
+        //   hd:true  → generateProfilePictureHD (preserves aspect ratio, caps at 1920, manages file size)
+        //   standard → generateProfilePicture (720×720 square crop, or custom dimensions)
+        const { img } = dimensions?.hd
+            ? await generateProfilePictureHD(content)
+            : await generateProfilePicture(content, dimensions);
         await query({
             tag: 'iq',
             attrs: {

package/lib/Utils/bot-planning-replay.js

@@ -2,22 +2,17 @@
  * Lia@Changes [WIP]
  * botPlanningReplay — Meta AI-style live reasoning feed.
  *
- * Sends a progress indicator with all steps IN_PROGRESS, then replays
- * each step completing in real time via sequential edits — exactly how
- * Meta AI's "Thinking…" bubble works. Final rich message lands clean
- * with NO "edited" badge, using the same delete-resend flow from
- * meta-compositing.
- *
- *   replayPlanning(sock, jid, steps, finalContent, options)
+ * UNIVERSAL VERSION: Works on ALL WhatsApp clients.
+ *   - Native Meta AI rendering for compatible clients
+ *   - Plain text fallback for regular clients (no "Update WhatsApp")
  *
  * Flow:
- *   Send placeholder (all steps IN_PROGRESS)
- *     → edit: step[0] → DONE  (stepDelayMs)
- *     → edit: step[1] → DONE  (stepDelayMs)
+ *   Send placeholder (all steps pending)
+ *     → edit: step[0] → DONE
+ *     → edit: step[1] → DONE
  *     → ...
- *     → edit: step[n] → DONE  (finalPauseMs)
  *     → delete placeholder
- *     → send final rich message fresh
+ *     → send final message fresh
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
  */
@@ -26,46 +21,32 @@ import { proto } from '../../WAProto/index.js';
 import {
     buildCompositingPlaceholder,
     buildProgressIndicator,
+    buildPlainPlaceholder,
     PlanningStepStatus
 } from './meta-compositing.js';
 import { botMetadataSignature, botMetadataCertificate } from './rich-message-utils.js';
 import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
 import { delay } from './generics.js';
 
-// ─── Internal: rebuild the full botForwardedMessage with updated step statuses ───────────────
+// ─── Internal: build native Meta AI frame ──────────────────────────────────
 const buildReplayFrame = (description, steps, placeholderText = '') => {
     return buildCompositingPlaceholder({ description, steps, placeholderText });
 };
 
-// ─── Internal: send an in-place edit of the planning bubble with new step states ─────────────
+// ─── Internal: edit planning bubble (native Meta AI) ───────────────────────
 const editPlanningBubble = async (sock, jid, key, description, steps, placeholderText) => {
     const updated = buildReplayFrame(description, steps, placeholderText);
-    // Use { edit: key, raw: true } — routes through protocolMessage.editedMessage
-    await sock.sendMessage(jid, {
-        raw: true,
-        edit: key,
-        ...updated
-    });
+    await sock.sendMessage(jid, { raw: true, edit: key, ...updated });
+};
+
+// ─── Internal: edit plain text bubble (universal) ──────────────────────────
+const editPlainBubble = async (sock, jid, key, description, steps, placeholderText) => {
+    const updated = buildPlainPlaceholder(description, steps, placeholderText);
+    await sock.sendMessage(jid, { edit: key, ...updated });
 };
 
 /**
- * replayPlanning — full live planning animation.
- *
- * @param {object}   sock                        - Baileys socket
- * @param {string}   jid                         - Destination JID
- * @param {Array}    steps                        - Array of step definitions:
- *                                                  { title, body?, isReasoning?, isEnhancedSearch? }
- *                                                  Status is managed automatically — do NOT pass status here.
- * @param {object}   finalContent                 - Rich content for the final message.
- *                                                  Same as sendMessage: { code, table, text, richResponse… }
- * @param {object}   [options]
- * @param {string}   [options.description]        - Top label while thinking. Default: 'Thinking…'
- * @param {string}   [options.placeholderText]    - Body text shown in bubble while loading.
- * @param {number}   [options.stepDelayMs]        - Ms between each step completing. Default: 900
- * @param {number}   [options.finalPauseMs]       - Ms to hold after all steps done before cleanup. Default: 600
- * @param {boolean}  [options.abortOnDisconnect]  - Stop replay loop if socket closes. Default: true
- * @param {object}   [options.sendOptions]        - Extra options for final sendMessage call.
- * @returns {Promise<object>} - The final sent WAMessage
+ * replayPlanning — full live planning animation (UNIVERSAL).
  */
 export const replayPlanning = async (sock, jid, steps, finalContent, {
     description = 'Thinking…',
@@ -73,13 +54,13 @@ export const replayPlanning = async (sock, jid, steps, finalContent, {
     stepDelayMs = 900,
     finalPauseMs = 600,
     abortOnDisconnect = true,
-    sendOptions = {}
+    sendOptions = {},
+    useNativeMeta = false
 } = {}) => {
     if (!steps?.length) {
         throw new Error('replayPlanning: steps array must have at least one entry');
     }
 
-    // ── Track abort state if socket disconnects mid-replay ───────────────────
     let aborted = false;
     const onClose = () => { aborted = true; };
     if (abortOnDisconnect) {
@@ -88,112 +69,96 @@ export const replayPlanning = async (sock, jid, steps, finalContent, {
         });
     }
 
-    // ── 1. Build initial state — all steps IN_PROGRESS ───────────────────────
+    // Show typing
+    await sock.sendPresenceUpdate('composing', jid);
+
+    // Build initial steps (all pending)
     const initialSteps = steps.map(step => ({
         ...step,
         status: PlanningStepStatus.IN_PROGRESS
     }));
 
-    const placeholder = await sock.sendMessage(jid, {
-        raw: true,
-        ...buildReplayFrame(description, initialSteps, placeholderText)
-    });
+    // Determine mode
+    const isNative = useNativeMeta && false; // Always false for now — force universal
+
+    // Send initial placeholder
+    let placeholder;
+    if (isNative) {
+        placeholder = await sock.sendMessage(jid, {
+            raw: true,
+            ...buildReplayFrame(description, initialSteps, placeholderText)
+        });
+    } else {
+        placeholder = await sock.sendMessage(jid,
+            buildPlainPlaceholder(description, initialSteps, placeholderText)
+        );
+    }
 
     const key = placeholder?.key;
 
-    // ── 2. Replay loop — flip each step to DONE sequentially ─────────────────
+    // Replay loop
     try {
         const currentSteps = [...initialSteps];
 
         for (let i = 0; i < currentSteps.length; i++) {
             if (aborted) break;
-
             await delay(stepDelayMs);
             if (aborted) break;
 
-            // Flip this step to DONE
-            currentSteps[i] = {
-                ...currentSteps[i],
-                status: PlanningStepStatus.DONE
-            };
+            currentSteps[i] = { ...currentSteps[i], status: PlanningStepStatus.DONE };
 
             if (key) {
-                await editPlanningBubble(
-                    sock, jid, key,
-                    description, currentSteps, placeholderText
-                );
+                if (isNative) {
+                    await editPlanningBubble(sock, jid, key, description, currentSteps, placeholderText);
+                } else {
+                    await editPlainBubble(sock, jid, key, description, currentSteps, placeholderText);
+                }
             }
         }
 
-        // ── 3. Hold with all steps DONE so user sees completion ──────────────
         if (!aborted && finalPauseMs > 0) {
             await delay(finalPauseMs);
         }
 
-        // ── 4. Delete placeholder silently ───────────────────────────────────
         if (key && !aborted) {
             await sock.sendMessage(jid, { delete: key });
         }
     } catch (err) {
-        // Non-fatal — always attempt final send even if replay failed mid-way
-        try {
-            if (key) await sock.sendMessage(jid, { delete: key });
-        } catch (_) {}
+        try { if (key) await sock.sendMessage(jid, { delete: key }); } catch (_) {}
     }
 
-    // ── 5. Send the final rich message as a brand-new message — no edited badge ──
+    await sock.sendPresenceUpdate('paused', jid);
+
+    // Skip final send if _skipFinalSend is set (for replayPlanningOnly)
+    if (sendOptions._skipFinalSend) return placeholder;
+
     return sock.sendMessage(jid, finalContent, sendOptions);
 };
 
 /**
- * replayPlanningOnly — same animation but WITHOUT sending a final message.
- * Use when you want to control the final send yourself.
- *
- * Returns { key } of the placeholder (already deleted on completion).
- *
- * @param {object} sock
- * @param {string} jid
- * @param {Array}  steps
- * @param {object} [options]   - Same options as replayPlanning minus sendOptions
- * @returns {Promise<void>}
+ * replayPlanningOnly — animation WITHOUT final message.
  */
 export const replayPlanningOnly = async (sock, jid, steps, options = {}) => {
     return replayPlanning(sock, jid, steps, null, {
         ...options,
-        _skipFinalSend: true
+        sendOptions: { ...options.sendOptions, _skipFinalSend: true }
     });
 };
 
 /**
- * buildReasoningSteps — convenience builder for steps with isReasoning: true.
- * Renders with the "reasoning" visual treatment in the Meta bubble.
- *
- * @example
- * buildReasoningSteps(['Analyzing the problem…', 'Checking edge cases…'])
+ * buildReasoningSteps — steps with isReasoning: true.
  */
 export const buildReasoningSteps = (titles) =>
     titles.map(title => ({ title, isReasoning: true }));
 
 /**
- * buildSearchSteps — convenience builder for steps with isEnhancedSearch: true.
- * Renders with the "enhanced search" visual treatment.
- *
- * @example
- * buildSearchSteps(['Searching the web…', 'Reading top results…'])
+ * buildSearchSteps — steps with isEnhancedSearch: true.
  */
 export const buildSearchSteps = (titles) =>
     titles.map(title => ({ title, isEnhancedSearch: true }));
 
 /**
- * mixedSteps — build a steps array mixing reasoning + search + plain steps.
- * Pass an array of { title, type? } where type is 'reasoning' | 'search' | undefined.
- *
- * @example
- * mixedSteps([
- *   { title: 'Understanding your question…', type: 'reasoning' },
- *   { title: 'Searching for data…',          type: 'search' },
- *   { title: 'Writing the answer…' }
- * ])
+ * mixedSteps — mix reasoning + search + plain steps.
  */
 export const mixedSteps = (defs) =>
     defs.map(({ title, body, type }) => ({

package/lib/Utils/messages-media.js

@@ -220,6 +220,80 @@ export const generateProfilePicture = async (mediaUpload, dimensions) => {
         img: await img
     };
 };
+// crysnovax@HD-Profile --- Like generateProfilePicture but skips resize/crop.
+// Re-encodes to JPEG so WA always gets valid image bytes.
+// crysnovax@HD-Profile --- HD mode: preserves original aspect ratio, no crop.
+// WhatsApp server accepts max 720px on any side. Images under 720px pass through
+// unchanged. Larger images are scaled down proportionally to fit within 720px.
+export const generateProfilePictureHD = async (mediaUpload) => {
+    let buffer;
+    if (Buffer.isBuffer(mediaUpload)) {
+        buffer = mediaUpload;
+    }
+    else {
+        const { stream } = await getStream(mediaUpload);
+        buffer = await toBuffer(stream);
+    }
+
+    const lib = await getImageProcessingLibrary();
+    let img;
+
+    if ('sharp' in lib && lib.sharp?.default) {
+        const metadata = await lib.sharp.default(buffer).metadata();
+        const origWidth = metadata.width || 720;
+        const origHeight = metadata.height || 720;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        // WhatsApp server limit: 720px max dimension
+        // If already under 720, send as-is. If larger, scale down proportionally.
+        const needsResize = maxDim > 720;
+
+        let pipeline = lib.sharp.default(buffer);
+
+        if (needsResize) {
+            pipeline = pipeline.resize(720, 720, {
+                fit: 'inside',
+                withoutEnlargement: true
+            });
+        }
+
+        img = pipeline
+            .jpeg({ quality: 85, mozjpeg: true })
+            .toBuffer();
+    }
+    else if ('image' in lib && lib.image?.Transformer) {
+        // @napi-rs/image — cap at 720 via resize
+        img = new lib.image
+            .Transformer(buffer)
+            .resize(720, 720)
+            .jpeg(85);
+    }
+    else if ('jimp' in lib && lib.jimp?.Jimp) {
+        const jimp = await lib.jimp.Jimp.read(buffer);
+        const origWidth = jimp.width;
+        const origHeight = jimp.height;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        let processed = jimp;
+        if (maxDim > 720) {
+            const scale = 720 / maxDim;
+            processed = jimp.resize({
+                w: Math.round(origWidth * scale),
+                h: Math.round(origHeight * scale),
+                mode: lib.jimp.ResizeStrategy.BILINEAR
+            });
+        }
+
+        img = processed.getBuffer('image/jpeg', { quality: 85 });
+    }
+    else {
+        throw new Boom('No image processing library available');
+    }
+
+    const result = await img;
+    console.log(`[HD-Profile] Output: ${result.length} bytes, dims preserved (max 720px)`);
+    return { img: result };
+};
 /** gets the SHA256 of the given media message */
 export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];

package/lib/Utils/meta-compositing.js

@@ -1,13 +1,12 @@
 /**
  * Lia@Changes [WIP]
- * Meta Compositing — send rich messages (code, table, text, etc.) with a
- * Meta AI-style progress indicator that appears BEFORE the final message.
+ * Meta Compositing — send rich messages with Meta AI-style progress indicator.
  *
- * The progress placeholder is sent first (with BotProgressIndicatorMetadata),
- * then deleted, then the final rich message is sent fresh — so NO "edited"
- * badge ever appears. Identical to how Meta AI itself works.
+ * UNIVERSAL VERSION: Works on ALL WhatsApp clients.
+ *   - Native Meta AI rendering for compatible clients (Beta, AI-enabled)
+ *   - Plain text fallback for regular clients (no "Update WhatsApp")
  *
- * metaTyping() — shows the "typing..." / planning steps indicator only.
+ * metaTyping() — shows the "typing..." / planning steps indicator.
  * sendMetaComposited() — full flow: typing → delete → final message.
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
@@ -19,18 +18,23 @@ import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
 import { generateWAMessageFromContent } from './messages.js';
 import { unixTimestampSeconds, delay } from './generics.js';
 
-// ─── Step status enum mirrors proto.BotProgressIndicatorMetadata.BotPlanningStepMetadata status field ───
+// ─── Step status enum ───
 export const PlanningStepStatus = {
     IN_PROGRESS: 0,
     DONE: 1,
     FAILED: 2
 };
 
+/**
+ * Check if recipient supports native Meta AI rendering.
+ * Always false for now — WhatsApp hasn't opened this to third-party bots.
+ */
+export const supportsMetaRendering = (jid, config = {}) => {
+    return config.forceMetaRendering === true;
+};
+
 /**
  * Build a BotProgressIndicatorMetadata object.
- * @param {string} description   - Top-level label shown while "thinking"
- * @param {Array}  steps         - Array of { title, body?, status?, isReasoning? }
- * @param {number} estimatedMs   - Optional estimated completion time in ms
  */
 export const buildProgressIndicator = (description, steps = [], estimatedMs) => {
     const stepsMetadata = steps.map(step => {
@@ -51,27 +55,16 @@ export const buildProgressIndicator = (description, steps = [], estimatedMs) =>
 };
 
 /**
- * Build the compositing placeholder message — the one that shows the
- * "Meta AI is thinking..." / planning steps indicator in the chat bubble.
- *
- * This is a botForwardedMessage with richResponseMessage = null content
- * but with progressIndicatorMetadata on the botMetadata.
- *
- * @param {object} options
- * @param {string} options.description        - "Thinking…" label
- * @param {Array}  options.steps              - Planning steps array
- * @param {number} [options.estimatedMs]      - Estimated completion ms
- * @param {string} [options.placeholderText]  - Text shown in the bubble body while loading
+ * Build the native Meta AI compositing placeholder (for compatible clients only).
  */
 export const buildCompositingPlaceholder = ({
     description = 'Thinking…',
     steps = [],
     estimatedMs,
     placeholderText = ''
-}) => {
+} = {}) => {
     const progressIndicatorMetadata = buildProgressIndicator(description, steps, estimatedMs);
 
-    // Minimal richResponseMessage so the bubble renders in Bot mode
     const textEncoder = new TextEncoder();
     const unifiedData = textEncoder.encode(JSON.stringify({
         response_id: crypto.randomUUID(),
@@ -119,90 +112,81 @@ export const buildCompositingPlaceholder = ({
 };
 
 /**
- * metaTyping — sends ONLY the progress/compositing indicator to a JID.
- * Does NOT delete or send a follow-up — caller controls that.
- *
- * Returns the sent message key so you can delete it later.
- *
- * @param {object} sock       - Baileys socket
- * @param {string} jid        - Destination JID
- * @param {object} options    - Same options as buildCompositingPlaceholder
- * @returns {Promise<object>} - The sent WAMessage
+ * Build a plain-text placeholder that works on ALL WhatsApp clients.
+ */
+export const buildPlainPlaceholder = (description = 'Thinking…', steps = [], placeholderText = '') => {
+    const stepLines = steps.map(step => {
+        const icon = step.status === PlanningStepStatus.DONE ? '✓' :
+                     step.status === PlanningStepStatus.FAILED ? '✗' : '○';
+        return `${icon} ${step.title}`;
+    }).join('\n');
+
+    let text = `_${description}_`;
+    if (stepLines) text += `\n\n${stepLines}`;
+    if (placeholderText) text += `\n\n${placeholderText}`;
+
+    return { text };
+};
+
+/**
+ * metaTyping — sends the progress/compositing indicator.
+ * UNIVERSAL: Uses plain text for regular clients, native Meta AI for compatible ones.
  */
 export const metaTyping = async (sock, jid, {
     description = 'Thinking…',
     steps = [],
     estimatedMs,
-    placeholderText = ''
+    placeholderText = '',
+    useNativeMeta = false
 } = {}) => {
-    const placeholder = buildCompositingPlaceholder({
-        description,
-        steps,
-        estimatedMs,
-        placeholderText
-    });
+    // Show typing indicator
+    await sock.sendPresenceUpdate('composing', jid);
+
+    if (useNativeMeta && supportsMetaRendering(jid, sock.config)) {
+        const placeholder = buildCompositingPlaceholder({
+            description, steps, estimatedMs, placeholderText
+        });
+        return sock.sendMessage(jid, { raw: true, ...placeholder });
+    }
 
-    return sock.sendMessage(jid, { raw: true, ...placeholder });
+    // Universal fallback: plain text placeholder
+    const plainSteps = steps.map(s => ({ ...s, status: PlanningStepStatus.IN_PROGRESS }));
+    const placeholder = buildPlainPlaceholder(description, plainSteps, placeholderText);
+    return sock.sendMessage(jid, placeholder);
 };
 
 /**
- * sendMetaComposited — full Meta AI flow:
- *   1. Send progress indicator placeholder
- *   2. Wait `thinkingMs` (default 2000ms)
- *   3. Delete the placeholder (no "edited" badge ever appears)
- *   4. Send the final rich message fresh
- *
- * Supports all existing richResponse content types: text, code, table,
- * expressions (LaTeX), items (reels carousel), or the richResponse array.
- *
- * @param {object} sock            - Baileys socket
- * @param {string} jid             - Destination JID
- * @param {object} content         - Same content object as sendMessage richResponse
- * @param {object} [options]
- * @param {number} [options.thinkingMs=2000]          - How long placeholder shows
- * @param {string} [options.description='Thinking…']  - Placeholder label
- * @param {Array}  [options.steps=[]]                 - Planning steps to show
- * @param {string} [options.placeholderText='']       - Body text while loading
- * @param {object} [options.sendOptions={}]           - Extra options for final sendMessage
- * @returns {Promise<object>} - The final sent WAMessage
+ * sendMetaComposited — full Meta AI flow (UNIVERSAL).
+ *   1. Send progress indicator
+ *   2. Wait thinkingMs
+ *   3. Delete placeholder
+ *   4. Send final message fresh
  */
 export const sendMetaComposited = async (sock, jid, content, {
     thinkingMs = 2000,
     description = 'Thinking…',
     steps = [],
     placeholderText = '',
-    sendOptions = {}
+    sendOptions = {},
+    useNativeMeta = false
 } = {}) => {
-    // 1. Send the compositing placeholder
     const placeholder = await metaTyping(sock, jid, {
-        description,
-        steps,
-        placeholderText
+        description, steps, estimatedMs: thinkingMs, placeholderText, useNativeMeta
     });
 
     try {
-        // 2. Wait — this is the "thinking" window
         await delay(thinkingMs);
-
-        // 3. Delete the placeholder silently
         if (placeholder?.key) {
             await sock.sendMessage(jid, { delete: placeholder.key });
         }
-    } catch (_) {
-        // Non-fatal — always attempt final send
-    }
+    } catch (_) {}
 
-    // 4. Send the final rich message as a brand-new message (no edit = no badge)
+    await sock.sendPresenceUpdate('paused', jid);
     return sock.sendMessage(jid, content, sendOptions);
 };
 
 /**
- * Convenience: build a steps array from plain strings with IN_PROGRESS status.
- * Use PlanningStepStatus.DONE to mark a step complete.
- *
- * @example
- * buildSteps(['Searching…', 'Reading sources…', 'Writing response…'])
+ * Convenience: build a steps array from plain strings.
  */
 export const buildSteps = (titles, status = PlanningStepStatus.IN_PROGRESS) =>
     titles.map(title => ({ title, status }));
-

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@crysnovax/baileys",
-   "version": "2.6.1",
+   "version": "2.6.2",
    "description": "Premium Baileys fork ⚉ Meta compositing, bot planning replay, welcome flow, rich messages (code, table, LaTeX, reels), interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",