plogme 1.0.2 → 1.0.4

package/README.md

@@ -1,8 +1,8 @@
 # plogme
 
-A Node.js WhatsApp Web API client for building messaging integrations with authentication, media transfer, groups, interactive messages, status updates, and rich message composition.
+`plogme` is a Node.js WhatsApp Web client based on the Baileys protocol implementation. It supports authentication, media, groups, interactive messages, status updates, albums, native flows, rich responses, and experimental Meta AI-style message envelopes.
 
-> **Package naming note:** npm scoped packages require a scope and package name. The valid package form is `plogme`; the bare string `@plogme` is a scope, not an installable package name by itself.
+> **Experimental feature notice:** Rich responses, Meta AI-style metadata, HTML primitives, clipboard addon sections, carousels, and albums use WhatsApp Web protocol structures that may change without notice. Unsupported fields can be ignored, rejected, or rendered differently across WhatsApp versions.
 
 ## Installation
 
@@ -10,15 +10,7 @@ A Node.js WhatsApp Web API client for building messaging integrations with authe
 npm install plogme
 ```
 
-For a repository checkout:
-
-```bash
-npm install github:crysnovax/baileys
-```
-
-## Requirements
-
-The package supports current Node.js LTS releases. Use Node.js 20 or newer for the latest runtime and dependency compatibility.
+The current package version is **1.0.4**. Use Node.js 20 or newer.
 
 ## Quick start
 
@@ -33,164 +25,452 @@ import pino from 'pino'
 
 async function start() {
   const { state, saveCreds } = await useMultiFileAuthState('./session')
-  const socket = makeWASocket({
+  const sock = makeWASocket({
     auth: state,
     logger: pino({ level: 'silent' })
   })
 
-  socket.ev.on('creds.update', saveCreds)
-  socket.ev.on('connection.update', ({ connection, lastDisconnect }) => {
+  sock.ev.on('creds.update', saveCreds)
+  sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
     if (connection === 'open') console.log('Connected')
     if (connection === 'close') {
       const status = new Boom(lastDisconnect?.error)?.output?.statusCode
       if (status !== DisconnectReason.loggedOut) start()
     }
   })
-
-  socket.ev.on('messages.upsert', async ({ messages }) => {
-    const message = messages[0]
-    if (!message?.message) return
-    await socket.sendMessage(message.key.remoteJid, { text: 'Hello from plogme' })
-  })
 }
 
 start()
 ```
 
-## Authentication
+Keep authentication files private. Never commit session credentials, private keys, or `.env` files.
 
-The recommended authentication state is multi-file authentication:
+## Authentication and pairing
 
 ```js
-import { useMultiFileAuthState } from 'plogme'
-
 const { state, saveCreds } = await useMultiFileAuthState('./session')
-```
 
-Pairing codes can be requested after the socket has initialized:
+const sock = makeWASocket({ auth: state })
+sock.ev.on('creds.update', saveCreds)
 
-```js
-const code = await socket.requestPairingCode('15551234567')
+const code = await sock.requestPairingCode('15551234567')
 console.log(code)
 ```
 
-Keep authentication files private. Do not commit session credentials, private keys, or environment files to a public repository.
+Pairing codes require the socket to be initialized and a valid phone number in international format.
 
-## Text, mentions, and reactions
+## Ordinary text, mentions, reactions, and media
 
 ```js
-await socket.sendMessage(jid, { text: 'Hello!' })
+await sock.sendMessage(jid, { text: 'Hello!' })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   text: 'Hello @15551234567',
   mentions: ['15551234567@s.whatsapp.net']
 })
 
-await socket.sendMessage(jid, {
-  react: { text: '✅', key: message.key }
+await sock.sendMessage(jid, {
+  react: { text: '👍', key: message.key }
 })
 ```
 
-## Media
+Media examples:
 
 ```js
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   image: { url: './image.jpg' },
   caption: 'Image caption'
 })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   video: { url: './video.mp4' },
   caption: 'Video caption',
   gifPlayback: false
 })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   document: { url: './report.pdf' },
   mimetype: 'application/pdf',
   fileName: 'report.pdf'
 })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   audio: { url: './audio.ogg' },
   mimetype: 'audio/ogg; codecs=opus'
 })
 ```
 
-## Interactive messages
+## Profile name and About description
+
+WhatsApp exposes the personal profile description as the **About status**. In
+`plogme`, use `updateProfileStatus`—not `updateProfileDescription`—and pass a
+plain string:
+
+```js
+await sock.updateProfileStatus('Building helpful bots')
+await sock.updateProfileName('Cody AI')
+```
+
+This updates the connected account's own profile. It does not update a contact
+or group description.
+
+## Spoiler messages
+
+For media, use `spoiler: true`. The default native mode serializes the
+supported `contextInfo.isSpoiler` flag:
+
+```js
+await sock.sendMessage(jid, {
+  image: { url: './classified.jpg' },
+  caption: 'Open only when ready',
+  spoiler: true
+})
+```
+
+For clients that do not support native media spoilers, explicitly use the
+compatibility fallback. This sends a view-once envelope; it is **not** the
+same as a native spoiler:
+
+```js
+await sock.sendMessage(jid, {
+  video: { url: './reveal.mp4' },
+  spoiler: true,
+  mediaSpoilerMode: 'viewOnce'
+})
+```
+
+For text, the default fallback uses WhatsApp's rolling-out `||...||` spoiler
+formatting. Native text metadata can be requested with
+`spoilerMode: 'native'`. Rendering remains client-version dependent.
+
+```js
+await sock.sendMessage(jid, {
+  text: 'The ending is revealed here',
+  spoiler: true
+})
+```
+
+## Rich text and Markdown
+
+`sendRichText` sends Markdown-capable text inside a forwarded GenAI rich-response envelope. Markdown rendering depends on the recipient's WhatsApp client.
+
+```js
+await sock.sendRichText(jid, {
+  text: `**Heading**
+
+Normal text
+
+> This is a blockquote`
+})
+```
+
+A dedicated blockquote helper is also available:
+
+```js
+await sock.sendMarkdownQuote(jid, {
+  text: `Here is the instruction:
+
+> Use this exact logo image.`
+})
+```
+
+## Copy-to-clipboard controls
+
+There are two different clipboard-related features:
+
+1. `sendCopyButton` creates the inline GenAI `COPY_TO_CLIPBOARD` addon section.
+2. `sendRichTextCopy` and `sendQuoteCopy` place ordinary Markdown content and a clipboard addon section in the same rich response. The text does **not** need to contain a quote.
+
+Normal text with a copy action:
+
+```js
+await sock.sendRichTextCopy(jid, {
+  text: 'npm install plogme',
+  copyText: 'npm install plogme',
+  copyLabel: 'Copy command'
+})
+```
+
+The same behavior can be requested through `sendRichText` by supplying `copyText`:
+
+```js
+await sock.sendRichText(jid, {
+  text: 'This is ordinary text with a copy action.',
+  copyText: 'This is ordinary text with a copy action.',
+  copyLabel: 'Copy me'
+})
+```
+
+Quote plus copy action:
+
+```js
+await sock.sendQuoteCopy(jid, {
+  text: `Ready-to-paste instruction:
+
+> Use this exact logo image...`,
+  copyText: 'Use this exact logo image...',
+  copyLabel: 'Copy me'
+})
+```
+
+`COPY_TO_CLIPBOARD` is an in-message rich-response action. It is different from the separate copy/forward/like/dislike toolbar that WhatsApp may render below first-party Meta AI messages. That toolbar is client-generated and is not authoritatively controllable through this API.
+
+## Rich links, images, HTML, and menus
+
+```js
+await sock.sendRichLink(jid, {
+  text: 'Open the deployment site',
+  url: 'https://example.com'
+})
+
+await sock.sendRichImage(jid, {
+  url: 'https://example.com/image.jpg',
+  mimeType: 'image/jpeg'
+})
+
+await sock.sendHtmlMessage(jid, {
+  html: '<h1>Hello</h1><p>Rendered HTML content</p>'
+})
+```
+
+`sendHtmlMessage` uses an experimental HTML primitive. Do not pass untrusted user input into HTML without sanitizing it.
+
+The experimental rich menu helper accepts a header, body buttons, cards, and footer:
+
+```js
+await sock.richMenu(jid, {
+  header: { title: 'Deploy Suite' },
+  body: {
+    title: 'Choose an action',
+    buttons: [
+      { id: 'deploy', text: 'Deploy' },
+      { id: 'logs', text: 'View logs' }
+    ]
+  },
+  footer: { text: 'Example menu' }
+})
+```
+
+Always validate button IDs on the server. Never treat a user-controlled button ID as an authorization grant.
 
-The client supports button, list, template, carousel, and native-flow message structures exposed by the installed library version. A basic button example is:
+## Carousels and rich button grids
+
+Use `sendRichButtonGrid` for media cards with native-flow buttons. A carousel needs at least one valid image, video, or product header per card. The helper accepts either `buttons` or `nativeFlow`.
 
 ```js
-await socket.sendMessage(jid, {
+await sock.sendRichButtonGrid(jid, {
   text: 'Choose an option',
-  footer: 'Menu',
-  buttons: [
-    { buttonId: 'confirm', buttonText: { displayText: 'Confirm' }, type: 1 },
-    { buttonId: 'cancel', buttonText: { displayText: 'Cancel' }, type: 1 }
-  ],
-  headerType: 1
+  footer: 'Select one',
+  cards: [
+    {
+      image: { url: './first.jpg' },
+      title: 'First card',
+      caption: 'First card description',
+      buttons: [
+        { id: 'first', text: 'Select first' }
+      ]
+    },
+    {
+      image: { url: './second.jpg' },
+      title: 'Second card',
+      caption: 'Second card description',
+      buttons: [
+        { id: 'second', text: 'Select second' }
+      ]
+    }
+  ]
 })
 ```
 
-Always validate button input on the server. A button identifier is user-controlled input and must not be treated as an authorization grant.
+Supported button properties include `id`, `text`, `url`, `call`, and `copy`. Carousel cards must have valid media headers. A card containing only text is not a valid carousel card.
 
-## Groups
+For a single native-flow message:
+
+```js
+await sock.sendMessage(jid, {
+  text: 'Open the site',
+  nativeFlow: [
+    { url: 'https://example.com', text: 'Open' }
+  ]
+})
+```
+
+## Media albums
+
+Albums are sent as a parent album message followed by associated image or video child messages. Provide at least two media items:
+
+```js
+await sock.sendMessage(jid, {
+  album: [
+    {
+      image: { url: './image-1.jpg' },
+      caption: 'First image'
+    },
+    {
+      image: { url: './image-2.jpg' },
+      caption: 'Second image'
+    }
+  ]
+})
+```
+
+Album children are required to be actual `imageMessage` or `videoMessage` payloads. A `botForwardedMessage` or `richResponseMessage` cannot be nested as an album child. If rich text or a rich-response envelope is needed, send it as a separate message before or after the album.
+
+## Experimental bot metadata
+
+The following methods attach newer `WAProto` bot metadata fields through `messageContextInfo.botMetadata`. They are experimental and may have no visible effect unless the receiving client and server support the corresponding first-party feature.
+
+### Diagnostics metadata
+
+```js
+await sock.sendBotDiagnostics(jid, {
+  text: 'Diagnostics test',
+  botBackend: 1, // 0 = AAPI, 1 = CLIPPY
+  toolsUsed: ['web_search', 'image_search'],
+  isThinking: true
+})
+```
+
+### Command metadata
+
+```js
+await sock.sendBotCommand(jid, {
+  text: 'Command metadata test',
+  commandName: 'summarize',
+  commandDescription: 'Summarize the current conversation',
+  commandPrompt: 'Summarize the current conversation in five bullets'
+})
+```
+
+### Resolved tool-call metadata
 
 ```js
-const metadata = await socket.groupMetadata(groupJid)
-await socket.groupParticipantsUpdate(groupJid, [userJid], 'add')
-await socket.groupParticipantsUpdate(groupJid, [userJid], 'remove')
-await socket.groupSettingUpdate(groupJid, 'announcement')
+await sock.sendBotToolResult(jid, {
+  text: 'Tool result test',
+  toolCallId: `tool-${Date.now()}`,
+  resolutionData: {
+    status: 'success',
+    result: { value: 'Completed' }
+  }
+})
+```
+
+You may provide a pre-serialized result instead:
+
+```js
+await sock.sendBotToolResult(jid, {
+  text: 'Serialized result',
+  toolCallId: 'tool-123',
+  resolutionDataSerialized: JSON.stringify({
+    status: 'success',
+    value: 'Completed'
+  })
+})
 ```
 
-Group administration calls require the connected account to have the corresponding privileges. Applications should handle permission failures and disconnected sessions gracefully.
+These methods do not fabricate Meta's verification certificates or signatures. They should not be treated as a way to impersonate a first-party Meta AI response.
 
 ## Status updates
 
-Status messages can be sent with text, images, videos, captions, and mentions according to the message content supported by the current protocol version:
+Use `backgroundColor` rather than `backgroundArgb` in the high-level API:
 
 ```js
-await socket.sendMessage('status@broadcast', {
+await sock.sendStatus({
   text: 'Service status: online',
-  backgroundArgb: 0xff102a43,
+  backgroundColor: 0xff102a43,
   font: 2
+}, {
+  statusJidList: ['15551234567@s.whatsapp.net']
+})
+```
+
+Alternatively, send directly to `status@broadcast` when using the raw status protocol supported by the installed version.
+
+## Groups
+
+```js
+const metadata = await sock.groupMetadata(groupJid)
+await sock.groupParticipantsUpdate(groupJid, [userJid], 'add')
+await sock.groupParticipantsUpdate(groupJid, [userJid], 'remove')
+await sock.groupSettingUpdate(groupJid, 'announcement')
+```
+
+Group administration requires the corresponding privileges. Handle permission failures and disconnected sessions.
+
+### Group member labels
+
+`updateMemberLabel` sets the connected account's own custom member label in a
+group. The first argument must be the **group JID** (`123456789-123456@g.us`),
+not the member's individual JID:
+
+```js
+await sock.updateMemberLabel(groupJid, 'Developer')
+```
+
+To remove the label, pass an empty string:
+
+```js
+await sock.updateMemberLabel(groupJid, '')
+```
+
+Labels are limited to 30 characters by the protocol. This is not an admin
+operation for assigning labels to arbitrary participants; WhatsApp associates
+the label with the account that sends the protocol message.
+
+## WhatsApp Flows and web views
+
+```js
+await sock.sendWhatsAppFlow(jid, {
+  flowId: '1234567890',
+  flowToken: 'example-token',
+  cta: 'Open flow',
+  text: 'Complete this form'
+})
+
+await sock.sendRichWebview(jid, {
+  url: 'https://example.com/app',
+  text: 'Open the app',
+  buttonText: 'Open'
 })
 ```
 
+The flow ID, token, and hosted URL must be valid for the target business configuration.
+
 ## Message options
 
 ```js
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   text: 'Disappearing message',
   ephemeralExpiration: 86400
 })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   text: 'Updated text',
   edit: message.key
 })
 
-await socket.sendMessage(jid, {
+await sock.sendMessage(jid, {
   delete: message.key
 })
 ```
 
-Use raw protocol options only when the target client and installed library version support them. Unsupported message fields can be rejected by WhatsApp or ignored by the recipient.
+Raw protocol fields are version-dependent. Unsupported fields may be ignored or rejected by WhatsApp.
 
 ## Error handling and reconnection
 
-Connections can close because of logout, network interruption, protocol updates, or server-side session invalidation. Applications should distinguish logout from recoverable failures and should avoid starting multiple concurrent connection loops.
+Connections may close because of logout, network interruption, protocol updates, or server-side session invalidation. Avoid starting multiple concurrent connection loops.
 
 ```js
-socket.ev.on('connection.update', ({ connection, lastDisconnect }) => {
+sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
   if (connection !== 'close') return
+
   const status = new Boom(lastDisconnect?.error)?.output?.statusCode
   if (status === DisconnectReason.loggedOut) {
-    console.error('Session logged out; remove the old session and pair again.')
+    console.error('Logged out; remove the old session and pair again.')
     return
   }
-  console.log('Connection interrupted; reconnect using a backoff strategy.')
+
+  console.log('Connection interrupted; reconnect with backoff.')
 })
 ```
 
@@ -201,12 +481,12 @@ npm install
 npm test
 ```
 
-Before opening a pull request, run the test suite, check the generated package contents, and confirm that no credentials or session files are included.
+Before publishing, verify generated protobuf files, package contents, version metadata, and that no authentication state or environment files are included.
 
 ## License
 
-Review the repository license before distributing applications built with this package. Keep required notices with redistributed source and binaries.
+Review the included license before distributing applications built with `plogme`. Keep required notices with redistributed source and binaries.
 
 ## Support
 
-For implementation questions, include the Node.js version, package version, operating system, relevant error text, and a minimal reproducible example. Never include authentication state or private account data in an issue.
+For implementation questions, include the Node.js version, `plogme` version, operating system, relevant error text, and a minimal reproducible example. Never include authentication state or private account data in an issue.

package/lib/Socket/messages-send.js

@@ -5,7 +5,7 @@ import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { prepareRichMenuMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareHtmlMessage } from '../Utils/rich-message-utils.js';
+import { prepareRichMenuMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareHtmlMessage } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
 import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/games/website-preview.js';
 import { isViewOnceMessage, extractViewOnceContent, getViewOnceMediaType, getViewOnceMediaContent, downloadViewOnceMedia, createRegularMessageFromViewOnce, parseViewOnceInfo } from '../Utils/view-once-utils.js';
@@ -2157,6 +2157,13 @@ export const makeMessagesSocket = (config) => {
                     delete content.ai;
                 }
 
+                if ('album' in content) {
+                    if (!Array.isArray(content.album) || content.album.length < 2) {
+                        throw new Boom('Album requires at least two image or video items', { statusCode: 400 });
+                    }
+                    fullMsg.message.messageContextInfo ||= {};
+                    fullMsg.message.messageContextInfo.messageSecret ||= randomBytes(32);
+                }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
@@ -2175,7 +2182,7 @@ export const makeMessagesSocket = (config) => {
 
                 if ('album' in content) {
                     const { delayMs = 1500 } = options;
-                    for (const albumMedia of content.album) {
+                    for (const [messageIndex, albumMedia] of content.album.entries()) {
                         const albumMsg = await generateWAMessage(jid, albumMedia, {
                             logger,
                             userJid,
@@ -2198,7 +2205,8 @@ export const makeMessagesSocket = (config) => {
                             // WhatsApp album child messages use association type 1.
                             // The generated MEDIA_ALBUM enum value (63) is a message
                             // category, not the child-association wire value.
-                            associationType: 1
+                            associationType: 1,
+                            messageIndex
                         };
                         await relayMessage(jid, albumMsg.message, {
                             messageId: albumMsg.key.id,
@@ -2252,7 +2260,7 @@ export const makeMessagesSocket = (config) => {
      */
     socket.sendRichText = async (jid, content = {}, options = {}) => {
         if (!jid) throw new Boom('sendRichText requires a target JID', { statusCode: 400 });
-        const wrapped = prepareRichTextMessage(content);
+        const wrapped = content.copyText ? prepareRichQuoteMessage(content) : prepareRichTextMessage(content);
         const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
             logger,
             userJid: authState.creds.me?.id,
@@ -2271,6 +2279,32 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    /** Sends ordinary Markdown/text with a GenAI COPY_TO_CLIPBOARD action; no quote syntax is required. */
+    socket.sendRichTextCopy = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendRichTextCopy requires a target JID', { statusCode: 400 });
+        if (!content.copyText) throw new Boom('sendRichTextCopy requires copyText content', { statusCode: 400 });
+        const wrapped = prepareRichQuoteMessage(content);
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
+    /** Sends Markdown text containing blockquotes in a forwarded GenAI rich response. */
+    socket.sendMarkdownQuote = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendMarkdownQuote requires a target JID', { statusCode: 400 });
+        const wrapped = prepareRichQuoteMessage(content);
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
+    /** Sends Markdown blockquotes followed by a GenAI COPY_TO_CLIPBOARD action. */
+    socket.sendQuoteCopy = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendQuoteCopy requires a target JID', { statusCode: 400 });
+        if (!content.copyText) throw new Boom('sendQuoteCopy requires copyText content', { statusCode: 400 });
+        const wrapped = prepareRichQuoteMessage(content);
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
     /**
      * Sends an image inside a forwarded GenAI rich response envelope.
      */
@@ -2340,6 +2374,42 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    /** Sends a rich response with experimental BotInfrastructureDiagnostics metadata. */
+    socket.sendBotDiagnostics = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotDiagnostics requires a target JID', { statusCode: 400 });
+        const { text = 'Bot diagnostics test', botBackend = 0, toolsUsed = [], isThinking = false, botJid = '867051314767696@bot' } = content;
+        const wrapped = {
+            messageContextInfo: { botMetadata: { botInfrastructureDiagnostics: { botBackend, toolsUsed, isThinking } } },
+            botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages: [{ messageType: 2, messageText: text }], contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4 } } } }
+        };
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
+    /** Sends a rich response with experimental BotCommandMetadata. */
+    socket.sendBotCommand = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotCommand requires a target JID', { statusCode: 400 });
+        const { text = 'Bot command test', commandName = '', commandDescription = '', commandPrompt = '', botJid = '867051314767696@bot' } = content;
+        const wrapped = {
+            messageContextInfo: { botMetadata: { commandMetadata: { commandName, commandDescription, commandPrompt } } },
+            botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages: [{ messageType: 2, messageText: text }], contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4 } } } }
+        };
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
+    /** Sends a rich response with experimental BotResolvedToolCallMetadata. */
+    socket.sendBotToolResult = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotToolResult requires a target JID', { statusCode: 400 });
+        const { text = 'Bot tool result test', toolCallId = `tool-${Date.now()}`, resolutionData, resolutionDataSerialized, botJid = '867051314767696@bot' } = content;
+        const wrapped = {
+            messageContextInfo: { botMetadata: { resolvedToolCallMetadata: { toolCallId, resolutionDataSerialized: resolutionDataSerialized ?? JSON.stringify(resolutionData ?? {}) } } },
+            botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages: [{ messageType: 2, messageText: text }], contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4 } } } }
+        };
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
     socket.sendStatus = async (content, options = {}) => {
         const statusJidList = await resolveStatusRecipients(options.statusJidList || content?.statusJidList);
         return socket.sendMessage(STATUS_JID, {

package/lib/Utils/games/website-preview.js

@@ -93,7 +93,7 @@ html,body{width:100%;height:100%;overflow:hidden;background:${bg};font-family:-a
 
 /* Toolbar */
 .toolbar{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;border-top:1px solid ${border};background:${barBg}}
-.toolbar .site-info{display:flex;align-items:center;gap:6px;font-size:11px;color:${textMuted]}
+.toolbar .site-info{display:flex;align-items:center;gap:6px;font-size:11px;color:${textMuted}}
 .toolbar .site-favicon{width:14px;height:14px;border-radius:3px;background:${border}}
 .toolbar .open-btn{display:inline-flex;align-items:center;gap:5px;padding:6px 14px;background:${linkColor};color:#fff;border:none;border-radius:8px;font-size:12px;font-weight:600;text-decoration:none;cursor:pointer}
 </style></head><body>
@@ -291,3 +291,4 @@ body{background:transparent;font-family:-apple-system,BlinkMacSystemFont,'Segoe
 };
 
 export default generateWebsitePreviewHtml;
+

package/lib/Utils/games/website-preview.js[bug]

@@ -0,0 +1,293 @@
+/**
+ * Website Preview — Mirror any website inside WhatsApp chat
+ * 
+ * Fetches an external website and renders it directly inside the chat bubble
+ * using FOAHtmlPrimitiveDemoDONOTUSE. The content is inlined (no iframe)
+ * so it works in WhatsApp's sandboxed WebView.
+ * 
+ * Usage:
+ *   const { generateWebsitePreviewHtml } = require('./website-preview');
+ *   const html = await generateWebsitePreviewHtml('https://example.com');
+ *   await sock.sendHtmlMessage(jid, { html });
+ */
+
+/**
+ * Fetch a website and return a self-contained HTML string
+ * that renders directly inside WhatsApp's chat bubble.
+ * 
+ * @param {string} url - The website URL to mirror
+ * @param {Object} [options]
+ * @param {string} [options.height='600px'] - Preview height
+ * @param {boolean} [options.showUrl=true] - Show the URL bar
+ * @param {boolean} [options.showToolbar=true] - Show toolbar with open link button
+ * @param {string} [options.theme='dark'] - 'dark' or 'light'
+ * @returns {string} Self-contained HTML string
+ */
+export const generateWebsitePreviewHtml = async (url, options = {}) => {
+    const { height = '600px', showUrl = true, showToolbar = true, theme = 'dark' } = options;
+    const baseUrl = new URL(url);
+    const isDark = theme === 'dark';
+
+    let fetchedHtml = '';
+    let fetchError = false;
+
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5'
+            },
+            redirect: 'follow',
+            signal: AbortSignal.timeout(10000)
+        });
+        fetchedHtml = await response.text();
+    } catch (err) {
+        fetchError = true;
+    }
+
+    // Extract useful parts from fetched HTML
+    const extracted = extractContent(fetchedHtml, url);
+
+    const bg = isDark ? '#0a0a0a' : '#ffffff';
+    const text = isDark ? '#e0e0e0' : '#1a1a1a';
+    const textMuted = isDark ? '#888' : '#666';
+    const border = isDark ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)';
+    const barBg = isDark ? '#1a1a2e' : '#f5f5f5';
+    const linkColor = '#4CAF50';
+
+    return `<html><head><style>
+*{box-sizing:border-box;margin:0;padding:0}
+html,body{width:100%;height:100%;overflow:hidden;background:${bg};font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif}
+.webview{width:100%;height:${height};position:relative;border-radius:12px;overflow:hidden;border:1px solid ${border};background:${bg}}
+
+/* URL Bar */
+.url-bar{display:flex;align-items:center;gap:8px;padding:8px 12px;background:${barBg};border-bottom:1px solid ${border};font-size:12px}
+.url-bar .lock{color:${linkColor};font-size:11px}
+.url-bar .url{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:${textMuted}}
+.url-bar .refresh{cursor:pointer;color:${linkColor};padding:4px;font-size:14px}
+
+/* Content Area */
+.content{width:100%;height:calc(100% - ${showUrl ? '36px' : '0px'} - ${showToolbar ? '44px' : '0px'});overflow-y:auto;overflow-x:hidden;-webkit-overflow-scrolling:touch;scrollbar-width:thin;scrollbar-color:${isDark ? '#333' : '#ccc'} transparent}
+.content::-webkit-scrollbar{width:4px}
+.content::-webkit-scrollbar-thumb{background:${isDark ? '#333' : '#ccc'};border-radius:2px}
+
+/* Extracted site content */
+.site-title{font-size:18px;font-weight:700;color:${text};margin-bottom:8px}
+.site-desc{font-size:13px;color:${textMuted};line-height:1.5;margin-bottom:12px}
+.site-text{font-size:14px;color:${text};line-height:1.7}
+.site-text a{color:${linkColor};text-decoration:none}
+.site-text img{max-width:100%;height:auto;border-radius:8px;margin:8px 0;display:block}
+.site-headings{font-size:15px;font-weight:600;color:${text};margin:16px 0 6px}
+.site-list{padding-left:18px;font-size:13px;color:${text};line-height:1.8}
+.site-links{display:flex;flex-wrap:wrap;gap:6px;margin-top:10px}
+.site-link{display:inline-block;padding:4px 10px;background:${barBg};border:1px solid ${border};border-radius:6px;font-size:12px;color:${linkColor};text-decoration:none}
+.site-images{display:grid;grid-template-columns:repeat(2,1fr);gap:6px;margin:10px 0}
+.site-images img{width:100%;height:80px;object-fit:cover;border-radius:6px;background:${barBg}}
+
+/* Error / Fallback state */
+.error-state{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100%;padding:30px;text-align:center}
+.error-state .icon{font-size:48px;margin-bottom:12px}
+.error-state h3{font-size:16px;color:${text};margin-bottom:6px}
+.error-state p{font-size:13px;color:${textMuted};margin-bottom:16px;line-height:1.5}
+
+/* Toolbar */
+.toolbar{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;border-top:1px solid ${border};background:${barBg}}
+.toolbar .site-info{display:flex;align-items:center;gap:6px;font-size:11px;color:${textMuted]}
+.toolbar .site-favicon{width:14px;height:14px;border-radius:3px;background:${border}}
+.toolbar .open-btn{display:inline-flex;align-items:center;gap:5px;padding:6px 14px;background:${linkColor};color:#fff;border:none;border-radius:8px;font-size:12px;font-weight:600;text-decoration:none;cursor:pointer}
+</style></head><body>
+<div class="webview">
+    ${showUrl ? `
+    <div class="url-bar">
+        <span class="lock">🔒</span>
+        <span class="url">${baseUrl.hostname}${baseUrl.pathname.length > 1 ? baseUrl.pathname.substring(0, 30) + '...' : ''}</span>
+        <span class="refresh" onclick="location.reload()">↻</span>
+    </div>` : ''}
+    
+    <div class="content">
+        ${fetchError ? `
+        <div class="error-state">
+            <div class="icon">🌐</div>
+            <h3>${baseUrl.hostname}</h3>
+            <p>Could not load this website directly. Tap the button below to open it in your browser.</p>
+            <a href="${url}" style="display:inline-flex;align-items:center;gap:5px;padding:10px 20px;background:${linkColor};color:#fff;border-radius:8px;text-decoration:none;font-size:13px;font-weight:600">🔗 Open Website</a>
+        </div>` : `
+        ${extracted.title ? `<div style="padding:16px">` : `<div style="padding:16px">`}
+            ${extracted.favicon ? `<img src="${extracted.favicon}" style="width:20px;height:20px;border-radius:4px;margin-bottom:8px" onerror="this.style.display='none'">` : ''}
+            ${extracted.title ? `<div class="site-title">${escapeHtml(extracted.title)}</div>` : ''}
+            ${extracted.description ? `<div class="site-desc">${escapeHtml(extracted.description)}</div>` : ''}
+            ${extracted.heroImage ? `<img src="${escapeHtml(extracted.heroImage)}" style="width:100%;border-radius:8px;margin-bottom:12px" onerror="this.style.display='none'">` : ''}
+            ${extracted.images.length > 0 ? `
+            <div class="site-images">
+                ${extracted.images.slice(0, 6).map(img => `<img src="${escapeHtml(img)}" onerror="this.style.display='none'" loading="lazy">`).join('')}
+            </div>` : ''}
+            ${extracted.headings.length > 0 ? extracted.headings.slice(0, 5).map(h => `<div class="site-headings">${escapeHtml(h)}</div>`).join('') : ''}
+            ${extracted.text ? `<div class="site-text">${escapeHtml(extracted.text).substring(0, 2000)}</div>` : ''}
+            ${extracted.links.length > 0 ? `
+            <div class="site-links">
+                ${extracted.links.slice(0, 8).map(l => `<a href="${escapeHtml(l.url)}" class="site-link">${escapeHtml(l.text)}</a>`).join('')}
+            </div>` : ''}
+        </div>`}
+    </div>
+    
+    ${showToolbar ? `
+    <div class="toolbar">
+        <div class="site-info">
+            <div class="site-favicon"></div>
+            <span>${baseUrl.hostname}</span>
+        </div>
+        <a href="${url}" class="open-btn">🔗 Open Site</a>
+    </div>` : ''}
+</div>
+</body></html>`;
+};
+
+/**
+ * Extract meaningful content from fetched HTML
+ */
+function extractContent(html, baseUrl) {
+    if (!html) return { title: '', description: '', text: '', headings: [], links: [], images: [], favicon: '', heroImage: '' };
+
+    const base = new URL(baseUrl);
+    
+    // Title
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    let title = titleMatch ? titleMatch[1].trim() : '';
+
+    // Meta description
+    const descMatch = html.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i)
+        || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i);
+    const description = descMatch ? descMatch[1].trim() : '';
+
+    // Favicon
+    const faviconMatch = html.match(/<link[^>]*rel=["'](?:shortcut )?icon["'][^>]*href=["']([^"']+)["']/i);
+    let favicon = faviconMatch ? resolveUrl(faviconMatch[1], base) : `${base.origin}/favicon.ico`;
+
+    // Hero image (og:image)
+    const ogImageMatch = html.match(/<meta[^>]*property=["']og:image["'][^>]*content=["']([^"']+)["']/i)
+        || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*property=["']og:image["']/i);
+    const heroImage = ogImageMatch ? resolveUrl(ogImageMatch[1], base) : '';
+
+    // Extract headings
+    const headings = [];
+    const headingRegex = /<h[1-6][^>]*>([^<]+)<\/h[1-6]>/gi;
+    let hm;
+    while ((hm = headingRegex.exec(html)) !== null) {
+        headings.push(hm[1].trim());
+    }
+
+    // Extract links
+    const links = [];
+    const linkRegex = /<a[^>]*href=["']([^"']+)["'][^>]*>([^<]*)<\/a>/gi;
+    let lm;
+    while ((lm = linkRegex.exec(html)) !== null) {
+        const href = lm[1].trim();
+        const text = lm[2].trim();
+        if (text && href && !href.startsWith('#') && !href.startsWith('javascript:')) {
+            links.push({ text: text.substring(0, 50), url: resolveUrl(href, base) });
+        }
+    }
+
+    // Extract images
+    const images = [];
+    const imgRegex = /<img[^>]*src=["']([^"']+)["'][^>]*>/gi;
+    let im;
+    while ((im = imgRegex.exec(html)) !== null) {
+        const src = im[1].trim();
+        if (src && !src.startsWith('data:')) {
+            images.push(resolveUrl(src, base));
+        }
+    }
+
+    // Extract text content (strip tags)
+    let text = html
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, '')
+        .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, '')
+        .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+
+    // Take a reasonable chunk of text
+    if (text.length > 2000) {
+        text = text.substring(0, 2000) + '...';
+    }
+
+    return { title, description, text, headings: headings.slice(0, 10), links: links.slice(0, 20), images: images.slice(0, 12), favicon, heroImage };
+}
+
+/**
+ * Resolve a relative URL against a base
+ */
+function resolveUrl(href, base) {
+    try {
+        if (href.startsWith('http://') || href.startsWith('https://')) return href;
+        if (href.startsWith('//')) return base.protocol + href;
+        return new URL(href, base).href;
+    } catch {
+        return href;
+    }
+}
+
+/**
+ * Escape HTML entities for safe embedding
+ */
+function escapeHtml(str) {
+    if (!str) return '';
+    return String(str)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+
+/**
+ * Generate a simple link preview (thumbnail + title + description)
+ * without fetching — lighter weight alternative.
+ * 
+ * @param {string} url - The URL to preview
+ * @param {Object} [options]
+ * @param {string} [options.title] - Override title
+ * @param {string} [options.description] - Override description
+ * @param {string} [options.image] - Override image URL
+ * @returns {string} HTML string for link preview card
+ */
+export const generateLinkPreviewHtml = (url, options = {}) => {
+    const { title, description, image } = options;
+    const baseUrl = new URL(url);
+    
+    return `<html><head><style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:transparent;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;padding:0}
+.card{background:#1a1a2e;border:1px solid rgba(255,255,255,0.1);border-radius:12px;overflow:hidden;max-width:100%}
+.card-image{width:100%;height:160px;object-fit:cover;background:linear-gradient(135deg,#1a1a2e,#2d2d44)}
+.card-body{padding:14px}
+.card-title{font-size:16px;font-weight:600;color:#fff;margin-bottom:4px}
+.card-desc{font-size:13px;color:#aaa;line-height:1.4;margin-bottom:8px}
+.card-url{font-size:11px;color:#4CAF50;display:flex;align-items:center;gap:4px}
+</style></head><body>
+<a href="${url}" target="_blank" style="text-decoration:none">
+    <div class="card">
+        ${image ? `<img class="card-image" src="${image}" alt="" onerror="this.style.display='none'">` : 
+        `<div class="card-image" style="display:flex;align-items:center;justify-content:center;font-size:48px">🌐</div>`}
+        <div class="card-body">
+            <div class="card-title">${escapeHtml(title || baseUrl.hostname)}</div>
+            <div class="card-desc">${escapeHtml(description || 'Click to visit ' + baseUrl.hostname)}</div>
+            <div class="card-url">🔒 ${baseUrl.hostname}</div>
+        </div>
+    </div>
+</a>
+</body></html>`;
+};
+
+export default generateWebsitePreviewHtml;

package/lib/Utils/messages.js

@@ -1222,18 +1222,21 @@ export const generateWAMessageContent = async (message, options) => {
                         throw new Boom('Invalid media type for carousel card', { statusCode: 400 });
                     }
                     const carouselCard = {
-                        nativeFlowMessage: prepareNativeFlowButtons(card.nativeFlow ? card : [])
+                        nativeFlowMessage: prepareNativeFlowButtons({
+                            ...card,
+                            nativeFlow: card.nativeFlow || card.buttons || []
+                        }),
+                        header: {
+                            title: card.title || '',
+                            subtitle: card.subtitle || '',
+                            hasMediaAttachment: isValidHeader
+                        }
                     };
                     if (hasOptionalProperty(card, 'text')) {
                         carouselCard.body = { text: card.text };
                     }
                     else {
                         if (hasOptionalProperty(card, 'caption')) {
-                            carouselCard.header = {
-                                title: card.title || '',
-                                subtitle: card.subtitle || '',
-                                hasMediaAttachment: isValidHeader
-                            };
                             carouselCard.body = { text: card.caption };
                         }
                         if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
@@ -1402,10 +1405,9 @@ export const generateWAMessageContent = async (message, options) => {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
         const mediaSpoiler = ['imageMessage', 'videoMessage', 'documentMessage', 'stickerMessage'].includes(messageType);
-        // View-once is the only broadly supported WhatsApp envelope that
-        // withholds the media preview until the recipient opens/downloads it.
-        // Native spoiler metadata remains available as an explicit opt-in.
-        const mediaSpoilerMode = message.mediaSpoilerMode || options?.mediaSpoilerMode || 'viewOnce';
+        // Native media spoilers use contextInfo.isSpoiler. View-once remains an
+        // explicit compatibility fallback for clients that do not render it.
+        const mediaSpoilerMode = message.mediaSpoilerMode || options?.mediaSpoilerMode || 'native';
         if (mediaSpoiler && mediaSpoilerMode === 'viewOnce') {
             m = { viewOnceMessage: { message: m } };
         }
@@ -1416,7 +1418,8 @@ export const generateWAMessageContent = async (message, options) => {
             else if (key) {
                 key.contextInfo = { isSpoiler: true };
             }
-            m = { spoilerMessage: { message: m } };
+            // `spoilerMessage` is not a field in WAProto.Message. The native
+            // representation is the media message's contextInfo.isSpoiler bit.
         }
         else if (key && typeof key.text === 'string') {
             const nativeSpoiler = message.spoilerMode === 'native' || options?.spoilerMode === 'native';

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

@@ -494,6 +494,37 @@ export const prepareRichTextMessage = (options = {}) => {
     return wrapToBotForwardedMessage(richResponseMessage);
 };
 
+/** Builds Markdown text with an optional GenAI COPY_TO_CLIPBOARD action section. */
+export const prepareRichQuoteMessage = (options = {}) => {
+    const { text = '', copyText, copyLabel = copyText, alignment = 'END' } = options;
+    const sections = [{
+        __typename: 'GenAIUnifiedResponseSection',
+        view_model: {
+            __typename: 'GenAISingleLayoutViewModel',
+            primitive: { __typename: 'GenAIMarkdownTextUXPrimitive', text: String(text), inline_entities: [] },
+        },
+    }];
+    if (copyText) {
+        sections.push({
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAIAddonActionLayoutViewModel',
+                addon_action_type: 'COPY_TO_CLIPBOARD',
+                addon_action_alignment: alignment,
+                primitives: [{ __typename: 'GenAIMarkdownTextUXPrimitive', text: String(copyLabel || copyText), inline_entities: [] }],
+            },
+        });
+    }
+    const unified = { response_id: randomUUID(), sections };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 },
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
 /**
  * Builds a GenAI rich image message — an image rendered inside a forwarded rich response.
  * Uses GenAIImagePrimitive with preview and full image variants.
@@ -939,4 +970,4 @@ export const wrapToBotForwardedMessage = (richResponseMessage) => ({
         message: { richResponseMessage }
     }
 });
-//# sourceMappingURL=rich-message-utils.js.map
+//# sourceMappingURL=rich-message-utils.js.map

package/lib/index.d.ts

@@ -224,6 +224,12 @@ export interface RelayMessageOptions {
 
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
+    /** Update the connected account's WhatsApp About/profile status. */
+    updateProfileStatus(status: string): Promise<void>;
+    /** Update the connected account's profile name. */
+    updateProfileName(name: string): Promise<void>;
+    /** Set or clear the connected account's own custom label in a group. */
+    updateMemberLabel(groupJid: string, memberLabel: string): Promise<unknown>;
     /** Relay a prepared message with optional recipient/device-scoping compatibility controls. */
     relayMessage(jid: string, message: Record<string, unknown>, options?: RelayMessageOptions): Promise<unknown>;
     /** Send an experimental Meta AI-style rich menu with image, card buttons, and an optional URL footer. */
@@ -238,6 +244,18 @@ export interface WASocket {
     sendWhatsAppFlow(jid: string, flow: { flowId: string; flowToken: string; cta?: string; action?: string; actionPayload?: Record<string, unknown>; mode?: string; flowMessageVersion?: string | number; metadata?: Record<string, unknown>; text?: string; footer?: string; image?: unknown; caption?: string; nativeFlowName?: string }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a rich native-flow URL CTA that opens a hosted WebView/Mini App. */
     sendRichWebview(jid: string, content: { text?: string; title?: string; footer?: string; image?: unknown; caption?: string; buttonText?: string; url: string; useWebview?: boolean; toast?: string; [key: string]: unknown }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental bot infrastructure diagnostics metadata. */
+    sendBotDiagnostics(jid: string, content?: { text?: string; botBackend?: number; toolsUsed?: string[]; isThinking?: boolean; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental bot command metadata. */
+    sendBotCommand(jid: string, content?: { text?: string; commandName?: string; commandDescription?: string; commandPrompt?: string; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental resolved tool-call metadata. */
+    sendBotToolResult(jid: string, content?: { text?: string; toolCallId?: string; resolutionData?: unknown; resolutionDataSerialized?: string; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send Markdown text containing blockquotes in a forwarded GenAI rich response. */
+    sendMarkdownQuote(jid: string, content?: { text?: string; copyText?: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send Markdown blockquotes followed by a GenAI COPY_TO_CLIPBOARD action. */
+    sendQuoteCopy(jid: string, content: { text?: string; copyText: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send ordinary Markdown/text followed by a GenAI COPY_TO_CLIPBOARD action. */
+    sendRichTextCopy(jid: string, content: { text?: string; copyText: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a native AI image/video generation card with a GENERATING or READY state. */
     sendRichGeneration(jid: string, content?: RichGenerationContent, quoted?: unknown, options?: Record<string, unknown>): Promise<RichGenerationResult>;
     /** Edit an existing AI generation card in place using WhatsApp's type-14 edit protocol. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plogme",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Production-ready Baileys fork \u2689 with AI groups, Meta AI prompting, safe compositing fallbacks, rich responses, interactive messages, albums, newsletters, and communities \u2014 without antiban wrappers.",
   "main": "lib/index.js",
   "type": "module",
@@ -14,7 +14,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://pair.crysnovax.link"
+    "url": "https://github.com/crysnovax/bailey"
   },
   "files": [
     "lib/**/*",