@codexverified/baileys 2.13.13 → 2.17.17

package/README.md

@@ -1,11 +1,35 @@
-# @codexverified/baileys
+<div align="center">
 
-[![npm version](https://img.shields.io/npm/v/@codexverified/baileys.svg)](https://www.npmjs.com/package/@codexverified/baileys)
-[![node](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](#at-a-glance)
-[![license](https://img.shields.io/badge/license-MIT-blue.svg)](#license-and-maintenance)
-[![types](https://img.shields.io/badge/types-included-blue)](#at-a-glance)
+# BAILEYS 
 
-> A readable, carefully maintained Baileys distribution for building reliable WhatsApp integrations with codexverified/baileys.
+### **The intelligent interactive and productivity layer for WhatsApp protocols.**
+
+<img src="https://readme-typing-svg.demolab.com?font=Space+Mono&size=22&pause=1200&color=00FFF0&center=true&vCenter=true&width=900&height=70&repeat=true&lines=BAILEYS+PROTOCOL.;NODE.JS+%2B+TYPESCRIPT.;RICH+MESSAGES+%2B+MEDIA.;BUILD+RELIABLE+INTEGRATIONS." alt="CodexVerified Baileys animated keywords" />
+
+<img src="https://i.imgur.com/dBaSKWF.gif" height="16" width="88%" alt="animated coloured divider" />
+
+<img src="https://raw.githubusercontent.com/codexverified/CODEX-AI/main/assets/rolling-circle.svg" width="90" alt="CodexVerified rolling circle" />
+
+[![Version](https://img.shields.io/badge/version-2.14.14-00FFF0?style=for-the-badge&labelColor=07111F)](https://www.npmjs.com/package/@codexverified/baileys)
+[![Developer CODEX](https://img.shields.io/badge/Developer-CODEX-B88CFF?style=for-the-badge&logo=telegram&labelColor=07111F)](https://t.me/codexverified)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-7CFFB2?style=for-the-badge&logo=node.js&logoColor=white&labelColor=07111F)](https://nodejs.org/)
+[![Powered by codexverified/baileys](https://img.shields.io/badge/powered%20by-codexverified%2Fbaileys-25D366?style=for-the-badge&logo=whatsapp&logoColor=white&labelColor=07111F)](https://www.npmjs.com/package/@codexverified/baileys)
+[![License](https://img.shields.io/badge/license-MIT-B88CFF?style=for-the-badge&labelColor=07111F)](#license-and-maintenance)
+
+</div>
+
+<div align="center">
+
+[![Main WhatsApp Channel](https://img.shields.io/badge/WhatsApp%20Channel-Follow-25D366?style=for-the-badge&logo=whatsapp)](https://whatsapp.com/channel/0029Vb78BHmL2AU7fsANSH2y)
+[![Backup WhatsApp Channel](https://img.shields.io/badge/Backup%20Channel-Follow-25D366?style=for-the-badge&logo=whatsapp)](https://whatsapp.com/channel/0029Vb6sMEy96H4VI2w3I50F)
+[![Support Group](https://img.shields.io/badge/Support%20Group-Join-25D366?style=for-the-badge&logo=whatsapp)](https://chat.whatsapp.com/If0d4XKHITO2NUf6YvQ3Eg?s=cl&p=a&mlu=4&ilr=4)
+[![Telegram Channel](https://img.shields.io/badge/Telegram%20Channel-Join-26A5E4?style=for-the-badge&logo=telegram)](https://t.me/codex_tech_innovation)
+[![Telegram Group](https://img.shields.io/badge/Telegram%20Group-Join-26A5E4?style=for-the-badge&logo=telegram)](https://t.me/CODEXV3)
+[![Website](https://img.shields.io/badge/Website-Visit-00FFF0?style=for-the-badge&logo=vercel&logoColor=black)](https://codex-ai.site)
+
+</div>
+
+> A readable, carefully maintained Baileys distribution for building reliable WhatsApp integrations. built by codex 
 
 `@codexverified/baileys` is a Node.js and TypeScript library for creating WhatsApp automations over the Baileys protocol. It provides a socket-oriented API for authentication, messaging, media, interactive content, rich responses, newsletters, groups, communities, business features, account utilities, and carefully documented extensions.
 
@@ -40,7 +64,7 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.13.13` |
+| Version | `2.17.17` |
 | Runtime | Node.js 20 or newer |
 | Module format | ESM, with CommonJS compatibility where supported |
 | Type declarations | Included at `lib/index.d.ts` |
@@ -54,7 +78,7 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 | Method | Command | Notes |
 | --- | --- | --- |
 | From npm | `npm install @codexverified/baileys` | Standard install when published under your organization |
-| From local archive | `npm install ./codex-baileys-2.13.13.tgz` | Place the `.tgz` beside your application |
+| From local archive | `npm install ./codex-baileys-2.17.17.tgz` | Place the `.tgz` beside your application |
 | Source audit (no scripts) | `npm install --ignore-scripts` | Skips install hooks for local review |
 
 Both npm and archive installs use the same import name:
@@ -623,3 +647,226 @@ await sock.relayMessage(jid, preparedMessage, {
 ```
 
 The `participant` option targets recipient-only delivery in a one-to-one chat. `retryParticipants` or `participants` identifies a device for retry resend, while `isSecret`, `protected`, and `me` restrict delivery to the corresponding device classes. These options do not bypass WhatsApp permissions or authorization checks.
+
+| Added helper | Purpose |
+| --- | --- |
+| `sendAlbumMessage` | Sends two or more image/video items as an album. |
+| `sendRichTextCopy`, `sendMarkdownQuote`, `sendQuoteCopy` | Rich Markdown responses with optional copy-to-clipboard actions. |
+| `sendBotDiagnostics`, `sendBotCommand`, `sendBotToolResult` | Experimental bot metadata envelopes for diagnostics, commands, and resolved tool calls. |
+
+### Usage
+
+```ts
+await sock.sendAlbumMessage(jid, [
+  { type: 'image', data: { url: './one.jpg' } },
+  { type: 'image', data: { url: './two.jpg' } }
+], { caption: 'Album caption' })
+```
+
+```ts
+await sock.sendRichTextCopy(jid, {
+  text: '**Install command**\n\nnpm install @codexverified/baileys',
+  copyText: 'npm install @codexverified/baileys',
+  copyLabel: 'Copy command'
+})
+
+await sock.sendMarkdownQuote(jid, {
+  text: 'Instruction:\n\n> Use this exact configuration.'
+})
+```
+
+Bot metadata helpers are experimental and should not be used as authorization or security controls.
+
+```ts
+await sock.sendBotCommand(jid, {
+  text: 'Run deployment',
+  commandName: 'deploy',
+  commandDescription: 'Deploy the current build',
+  commandPrompt: 'Deploy the current build'
+})
+```
+
+
+
+
+### Full-width stacked albums
+
+`sendAlbumMessage` sends a rich vertical album rather than the legacy parent/child album collection. Each image or video is rendered as one large media item on its own row. Provide at least two publicly fetchable media URLs. Both `{ image: { url } }` and the typed `{ type: 'image', data: { url } }` forms are accepted.
+
+```js
+await sock.sendAlbumMessage(jid, [
+  { image: { url: 'https://example.com/one.jpg' } },
+  { image: { url: 'https://example.com/two.jpg' } },
+  { image: { url: 'https://example.com/three.jpg' } }
+], { caption: 'Codex album' })
+```
+
+The rich album path is URL-based and does not upload local buffers. Remove accidental whitespace from URLs before sending; the implementation trims URL values, but clean URLs are recommended.
+
+### A2UI command menu
+
+`sendA2UICommandMenu` sends the large command/function menu UI: an optional image header, title, command rows, URL buttons, and a native-flow fallback. The `rows` entries use `[command, description]` tuples, matching the menu layout shown in the WhatsApp client.
+
+```js
+await sock.sendA2UICommandMenu(jid, {
+  image: { url: 'https://example.com/menu.jpg' },
+  title: 'Speed menu',
+  rows: [
+    ['.menu', 'Main menu'],
+    ['.ping', 'Speed check']
+  ],
+  buttons: [
+    { text: 'Website', url: 'https://example.com' },
+    { text: 'Support', url: 'https://example.com/support' }
+  ]
+})
+```
+
+
+### AIRich command menu and video grid
+
+The compatibility update also exposes the two AIRich layouts that were not already present in Codex. `sendAIRichCommandMenu` sends the manually serialized command card with an image, Markdown command table, optional widget CTAs, and footer URL actions. The image must be a publicly fetchable URL.
+
+```ts
+await sock.sendAIRichCommandMenu(jid, {
+  image: 'https://example.com/menu.png',
+  title: 'CODEX AI',
+  subtitle: 'Choose a command',
+  rows: [
+    ['.menu', 'Show the main menu'],
+    ['.ping', 'Check service latency']
+  ],
+  buttons: [
+    { id: 'docs', text: 'Documentation', url: 'https://example.com/docs' }
+  ],
+  footer: 'Developed by - CODEX TECHNOLOGY'
+})
+```
+
+`sendVideoGridMessage` sends at least two video URL items as a `GenAIGridLayoutViewModel` containing `GenAIVideoPrimitive` entries. It is separate from `sendAlbumMessage`, which uses the vertical album layout.
+
+```ts
+await sock.sendVideoGridMessage(jid, [
+  {
+    url: 'https://cdn.example.com/first.mp4',
+    title: 'First clip',
+    thumbnailUrl: 'https://cdn.example.com/first.jpg',
+    progressiveUrls: ['https://cdn.example.com/first-720p.mp4']
+  },
+  {
+    url: 'https://cdn.example.com/second.mp4',
+    title: 'Second clip',
+    thumbnailUrl: 'https://cdn.example.com/second.jpg'
+  }
+])
+```
+
+Both layouts are experimental WhatsApp protocol structures. Client rendering can change, and callers should provide a plain-message fallback where reliability matters.
+
+
+### Bot planning responses
+
+`sendBotPlanning` sends a bot-planning rich response with a summary, ordered step text, and optional planning/query-plan capabilities.
+
+```ts
+await sock.sendBotPlanning(jid, {
+  text: 'Preparing the deployment',
+  steps: [
+    { title: 'Build', body: 'Compile the application' },
+    { title: 'Verify', body: 'Run the checks' },
+    'Publish the release'
+  ],
+  queryPlan: true
+})
+```
+
+### Newsletter invite metadata
+
+`newsletterGetInviteInfo` accepts either a channel invite code or a WhatsApp channel invite URL and returns the resolved newsletter metadata, or `null` when WhatsApp does not return a matching record.
+
+```ts
+const info = await sock.newsletterGetInviteInfo('https://whatsapp.com/channel/INVITE_CODE')
+console.log(info?.id, info?.name, info?.invite)
+```
+
+The lookup is an explicit network request and does not follow, join, or subscribe to the channel.
+
+
+### Carousel, compatibility aliases, and source search
+
+`sendCarousel` normalizes card media, captions, footers, and buttons before sending a carousel message.
+
+```ts
+await sock.sendCarousel(jid, [
+  {
+    title: 'Documentation',
+    body: { text: 'Read the API guide' },
+    media: { image: { url: 'https://example.com/docs.jpg' } },
+    buttons: [{ text: 'Open', id: 'docs' }]
+  }
+])
+```
+
+`HoldOn` is retained as a compatibility alias for `sendRichButtonGrid`. New applications should prefer the descriptive Codex-named method.
+
+`grepCode(pattern, options)` searches installed package source files and returns matching file, line, column, and source-line information. It is an explicit diagnostic helper and performs no network access.
+
+```ts
+const matches = sock.grepCode('prepareVideoGridMessage', { includeReadme: true })
+```
+
+### Interactive rich HTML
+
+The compatibility update also exposes `sendRichHtmlMessage`, which uses the interactive GenAI HTML primitive and supports embedded tabs. Only pass trusted, sanitized HTML; this is not a general-purpose HTML sanitizer.
+
+```ts
+await sock.sendRichHtmlMessage(jid, {
+  title: 'CODEX TECHNOLOGY',
+  html: '<h1>Hello</hi>',
+  url: 'https://codex-ai.site',
+  trustedSources: ['codex-ai.site']
+})
+```
+
+Multiple tabs can be supplied with `tabs`; each tab may provide its own `html`, `url`, and `trustedSources`. The structure is experimental and depends on WhatsApp client support.
+
+
+## Codex unified responses and the built-in mini-app
+
+`sendCodexMessage` accepts one object containing any supported combination of text, links, media, products, reels, tables, code, LaTeX, or suggestions. Unsupported optional sections are ignored by the rich-response serializer, so callers can use one stable entry point for heterogeneous response data.
+
+```js
+await sock.sendCodexMessage(jid, {
+  text: 'Here is your result',
+  links: [{ text: 'Open the docs', url: 'https://example.com/docs' }],
+  table: {
+    title: 'Summary',
+    headers: ['Name', 'Status'],
+    rows: [['Codex', 'Ready']]
+  }
+})
+```
+
+`sendMiniApp` sends the bundled interactive mini-app as a trusted rich HTML screen. The helper does not fetch or execute caller-provided remote code; pass only presentation options such as `title` and keep authentication or business actions on your own server.
+
+```js
+await sock.sendMiniApp(jid, {
+  title: 'Codex mini-app'
+}, {
+  quoted: message
+})
+```
+
+The package also exports `BotCapabilityType`, `normalizeBotCapabilities`, `buildBotCapabilityMetadata`, and `buildBotRichResponse` for applications that need to construct compatible bot metadata.
+
+<div align="center">
+
+<sub>Thanks for reading my README.</sub>
+
+<img src="https://i.imgur.com/dBaSKWF.gif" height="16" width="88%" alt="animated coloured footer line" />
+
+<br><br>
+
+<img src="https://capsule-render.vercel.app/api?type=waving&color=00FFF0&height=100&section=footer" alt="@codexverified/baileys footer" />
+
+</div>

package/lib/Socket/messages-send.js

@@ -12,12 +12,14 @@ import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinar
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { captureUnifiedResponse, generateButtonGridContent, generateCodeBlockContent, generateLatexContent, generateListContent, generateRichMenuContent, generateTableContent, generateUnifiedResponseContent } from '../Utils/message-composer.js';
 import { Baron } from './interactive-handler.js';
-import { prepareRichResponseMessage, prepareRichGenerationMessage, prepareRichTextMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareHtmlMessage } from '../Utils/rich-message-utils.js';
+import { prepareRichResponseMessage, prepareRichGenerationMessage, prepareRichTextMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareVideoGridMessage, prepareVerticalAlbumMessage, prepareHtmlMessage, prepareRichHtmlMessage } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
+import { generateMiniAppHtml } from '../Utils/games/miniapp.js';
 import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/website-preview.js';
 import { isViewOnceMessage, downloadViewOnceMedia, createRegularMessageFromViewOnce, parseViewOnceInfo } from '../Utils/view-once-utils.js';
 import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID } from './aigroups.js';
 import { makeUsernameSocket } from './username.js';
+import { grepSource } from '../Utils/source-grep.js';
 
 const STATUS_JID = 'status@broadcast';
 export const normalizeStatusJidList = (value) => {
@@ -1224,6 +1226,95 @@ export const makeMessagesSocket = (config) => {
             const recipients = normalizeStatusJidList(options.statusJidList || content?.statusJidList);
             return sock.sendMessage(STATUS_JID, { ...content, status: true }, { ...options, broadcast: true, statusJidList: recipients });
         },
+        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 fullMsg = await generateWAMessageFromContent(jid, prepareRichQuoteMessage(content), { 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;
+        },
+        sendMarkdownQuote: async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendMarkdownQuote requires a target JID', { statusCode: 400 });
+        const fullMsg = await generateWAMessageFromContent(jid, prepareRichQuoteMessage(content), { 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;
+        },
+        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 });
+        return socket.sendRichTextCopy(jid, content, options);
+        },
+        /** Send a full-width stacked AIRich album with one large image/video per row. */
+        sendAlbumMessage: async (jid, medias = [], options = {}) => {
+        if (!jid) throw new Boom('sendAlbumMessage requires a target JID', { statusCode: 400 });
+        if (!Array.isArray(medias) || medias.length < 2) throw new Boom('sendAlbumMessage requires at least two media items', { statusCode: 400 });
+        const albumItems = medias.map((media) => {
+            const raw = media?.type && media?.data ? media.data : (media?.image ?? media);
+            if (media?.video || media?.type === 'video') {
+                const video = media?.video || raw;
+                const sourceUrl = typeof video === 'string' ? video.trim() : String(video?.url || video?.videoUrl || '').trim();
+                if (!sourceUrl) throw new Boom('Each video album item requires a video URL', { statusCode: 400 });
+                return { type: 'video', video: { ...video, url: sourceUrl } };
+            }
+            const image = typeof raw === 'string' ? raw.trim() : { ...raw, url: String(raw?.url || '').trim() };
+            if (!image || (typeof image === 'object' && !image.url && !image.sourceUrl)) {
+                throw new Boom('Each image album item requires an image URL', { statusCode: 400 });
+            }
+            return { type: 'image', image };
+        });
+        const wrapped = prepareVerticalAlbumMessage({ items: albumItems, verificationMetadata: options.verificationMetadata });
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options
+        });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, ...options });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+        },
+        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;
+        return socket.sendRichGeneration(jid, { text, botMetadata: { botInfrastructureDiagnostics: { botBackend, toolsUsed, isThinking } }, botJid }, undefined, options);
+        },
+        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;
+        return socket.sendRichGeneration(jid, { text, botMetadata: { commandMetadata: { commandName, commandDescription, commandPrompt } }, botJid }, undefined, options);
+        },
+        /** Sends a planning/execution-plan rich response with WAProto capabilities. */
+        sendBotPlanning: async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotPlanning requires a target JID', { statusCode: 400 });
+        const { text = 'Execution plan', steps = [], queryPlan = true, botJid = '867051314767696@bot' } = content;
+        const submessages = [
+            { messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT, messageText: text },
+            ...steps.map(step => ({
+                messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT,
+                messageText: typeof step === 'string' ? step : `${step.title || step.name || 'Step'}${step.body ? `: ${step.body}` : ''}`
+            }))
+        ];
+        const wrapped = buildBotRichResponse({
+            botJid,
+            submessages,
+            capabilities: [
+                BotCapabilityType.AGENTIC_PLANNING,
+                ...(queryPlan ? [BotCapabilityType.QUERY_PLAN] : [])
+            ]
+        });
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayRichMessage(jid, fullMsg, options);
+        return fullMsg;
+        },
+        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;
+        return socket.sendRichGeneration(jid, { text, botMetadata: { resolvedToolCallMetadata: { toolCallId, resolutionDataSerialized: resolutionDataSerialized ?? JSON.stringify(resolutionData ?? {}) } }, botJid }, undefined, options);
+        },
         richMenu: async (jid, content = {}, options = {}) => {
             if (!jid) throw new Boom('richMenu requires a target JID', { statusCode: 400 });
             const message = generateRichMenuContent(content, options.quoted, options);
@@ -1231,6 +1322,48 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
             return fullMsg;
         },
+        /** Send the large A2UI command menu with an uploaded image header, rows, and URL buttons. */
+        /** Sends the manually serialized AIRich command card shown in the screenshot. */
+        sendAIRichCommandMenu: async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendAIRichCommandMenu requires a target JID', { statusCode: 400 });
+        const wrapped = prepareAIRichCommandMenu(content);
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options,
+        });
+        await relayRichMessage(jid, fullMsg, options);
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+        },
+        sendA2UICommandMenu: async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendA2UICommandMenu requires a target JID', { statusCode: 400 });
+        const { image, ...menuContent } = content || {};
+        let imageMessage;
+        if (image) {
+            const prepared = await prepareWAMessageMedia({ image }, { upload: waUploadToServer });
+            imageMessage = prepared.imageMessage;
+        }
+        const wrapped = prepareA2UICommandMenu({ ...menuContent, imageMessage });
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options
+        });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, ...options.relayOptions });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+        },
         sendRichButtonGrid: async (jid, grid, options = {}) => {
             const message = generateButtonGridContent(grid, options.quoted, options);
             const fullMsg = await generateWAMessageFromContent(jid, message, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
@@ -1250,6 +1383,8 @@ export const makeMessagesSocket = (config) => {
             const lines = [title, headers.length ? `| ${headers.map(String).join(' | ')} |` : '', headers.length ? `| ${headers.map(() => '---').join(' | ')} |` : '', ...rows.map(row => `| ${(Array.isArray(row) ? row : [row]).map(value => String(value ?? '')).join(' | ')} |`)].filter(Boolean);
             return sock.sendMessage(jid, { ...(image ? { image, caption: lines.join('\\n') } : { text: lines.join('\\n') }), buttons, ...(footer ? { footer } : {}) }, options);
         },
+        /** Compatibility alias for the former Gen4/grid menu entry point. */
+        HoldOn: async (jid, grid, options = {}) => socket.sendRichButtonGrid(jid, grid, options),
         sendWhatsAppFlow: async (jid, flow = {}, options = {}) => {
             const { text, footer, image, caption, flowId, flowToken, flowName = 'flow', flowAction = 'navigate', flowActionPayload = {} } = flow;
             if (!flowId || !flowToken) throw new Boom('sendWhatsAppFlow requires flowId and flowToken', { statusCode: 400 });
@@ -1274,6 +1409,38 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, message, { messageId });
             return { message, messageId };
         },
+        sendCarousel: async (jid, cards, options = {}) => {
+            if (!Array.isArray(cards) || cards.length === 0) {
+                throw new Boom('sendCarousel requires a non-empty cards array', { statusCode: 400 });
+            }
+            const normalizedCards = cards.map(card => ({
+                ...card,
+                text: card.text ?? card.body?.text,
+                caption: card.caption ?? card.body?.text,
+                footer: card.footer?.text ?? card.footer,
+                buttons: card.buttons ?? card.nativeFlowMessage?.buttons,
+                ...(card.media?.image ? { image: card.media.image } : {}),
+                ...(card.media?.video ? { video: card.media.video } : {}),
+                ...(card.media?.document ? { document: card.media.document } : {})
+            }));
+            const { text, footer, ...messageOptions } = options;
+            const fullMsg = await generateWAMessage(jid, {
+                ...messageOptions,
+                cards: normalizedCards,
+                ...(text !== undefined ? { text } : {}),
+                ...(footer !== undefined ? { footer } : {})
+            }, {
+                logger,
+                userJid: authState.creds.me?.id,
+                upload: waUploadToServer,
+                mediaCache: config.mediaCache,
+                options: config.options,
+                ...options,
+                messageId: options.messageId || generateMessageIDV2(jid)
+            });
+            await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, ...options });
+            return fullMsg;
+        },
         sendLatex: async (jid, quoted, options) => {
             const { message, messageId } = generateLatexContent(quoted, options);
             await relayMessage(jid, message, { messageId });
@@ -1480,6 +1647,31 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, message, { messageId });
             return { message, messageId };
         },
+        /** Send one tolerant AIRich response containing every supported section supplied in content. */
+        sendCodexMessage: async (jid, content = {}, quoted, options = {}) => {
+            if (!jid) throw new Boom('sendCodexMessage requires a target JID', { statusCode: 400 });
+            if (!content || typeof content !== 'object' || Array.isArray(content)) {
+                throw new Boom('sendCodexMessage content must be an object', { statusCode: 400 });
+            }
+            const message = prepareRichResponseMessage({
+                ...content,
+                noDonation: options.noDonation ?? true,
+            });
+            const fullMsg = generateWAMessageFromContent(jid, message, {
+                logger,
+                userJid: authState.creds.me?.id,
+                messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+                quoted,
+                ...options,
+            });
+            await relayMessage(jid, fullMsg, options);
+            if (config.emitOwnEvents) {
+                process.nextTick(async () => {
+                    await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                });
+            }
+            return fullMsg;
+        },
         captureAndResendUnifiedResponse: async (jid, metaAiMsg, quoted) => {
             const captured = captureUnifiedResponse(metaAiMsg);
             if (!captured) {
@@ -2220,6 +2412,35 @@ export const makeMessagesSocket = (config) => {
         return { message, messageId };
     };
 
+    /**
+     * Sends a unified-response video grid. This uses GenAIVideoPrimitive items
+     * inside GenAIGridLayoutViewModel; it is not the image-only GRID_IMAGE type.
+     */
+    socket.sendVideoGridMessage = async (jid, videos = [], options = {}) => {
+        if (!jid) throw new Boom('sendVideoGridMessage requires a target JID', { statusCode: 400 });
+        if (!Array.isArray(videos) || videos.length < 2) {
+            throw new Boom('sendVideoGridMessage requires at least two videos', { statusCode: 400 });
+        }
+        const wrapped = prepareVideoGridMessage({
+            videos,
+            verificationMetadata: options.verificationMetadata
+        });
+        const fullMsg = generateWAMessageFromContent(jid, wrapped, {
+            logger,
+            userJid: authState.creds.me?.id,
+            messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id || jid),
+            ...options
+        });
+        await relayRichMessage(jid, fullMsg, options);
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+
+
     socket.sendHtmlMessage = async (jid, content = {}, options = {}) => {
         if (!jid) throw new Boom('sendHtmlMessage requires a target JID', { statusCode: 400 });
         if (!content.html) throw new Boom('sendHtmlMessage requires html content', { statusCode: 400 });
@@ -2228,10 +2449,32 @@ export const makeMessagesSocket = (config) => {
         return fullMsg;
     };
 
+    /** Sends an interactive GenAI HTML screen with embedded tabs. */
+    socket.sendRichHtmlMessage = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendRichHtmlMessage requires a target JID', { statusCode: 400 });
+        if (!content.html && !(Array.isArray(content.tabs) && content.tabs.length)) throw new Boom('sendRichHtmlMessage requires html or tabs content', { statusCode: 400 });
+        const wrapped = prepareRichHtmlMessage(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;
+    };
+    /** Find a word or expression in the installed package source. */
+    socket.grepCode = (pattern, options = {}) => grepSource(pattern, options);
+
     socket.sendSlotMachine = async (jid, options = {}, sendOptions = {}) => {
         return socket.sendHtmlMessage(jid, { html: generateSlotMachineHtml(options) }, sendOptions);
     };
 
+    /** Send the built-in interactive Codex mini-app through the rich HTML envelope. */
+    socket.sendMiniApp = async (jid, options = {}, sendOptions = {}) => {
+        if (!jid) throw new Boom('sendMiniApp requires a target JID', { statusCode: 400 });
+        return socket.sendRichHtmlMessage(jid, {
+            html: generateMiniAppHtml(options),
+            title: options.title || 'mini-app',
+            url: 'https://codex-ai.site',
+            trustedSources: ['codex-ai.site']
+        }, sendOptions);
+    };
     socket.sendWebsitePreview = async (jid, url, options = {}, sendOptions = {}) => {
         if (!url) throw new Boom('sendWebsitePreview requires a URL', { statusCode: 400 });
         return socket.sendHtmlMessage(jid, { html: await generateWebsitePreviewHtml(url, options) }, sendOptions);

package/lib/Socket/newsletter.js

@@ -1,3 +1,4 @@
+import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { QueryIds, XWAPaths } from '../Types/index.js';
 import { generateProfilePicture } from '../Utils/messages-media.js';
@@ -34,6 +35,15 @@ const parseNewsletterMetadata = (result) => {
     }
     return null;
 };
+const normalizeNewsletterInviteCode = (value) => {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Boom('newsletterGetInviteInfo requires a non-empty invite code or URL', { statusCode: 400 });
+    }
+    return value.trim()
+        .replace(/^https?:\/\/(?:www\.)?whatsapp\.com\/channel\//i, '')
+        .replace(/^https?:\/\/wa\.me\/channel\//i, '')
+        .split(/[/?#]/, 1)[0];
+};
 export const makeNewsletterSocket = (config) => {
     const sock = makeAIGroupsSocket(config);
     const { query, generateMessageTag } = sock;
@@ -84,6 +94,14 @@ export const makeNewsletterSocket = (config) => {
             const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata);
             return parseNewsletterMetadata(result);
         },
+        newsletterGetInviteInfo: async (inviteCodeOrUrl) => {
+            const inviteCode = normalizeNewsletterInviteCode(inviteCodeOrUrl);
+            return executeWMexQuery(
+                { input: { key: inviteCode, type: 'INVITE' }, fetch_creation_time: true, fetch_full_image: true, fetch_viewer_metadata: true },
+                QueryIds.METADATA,
+                XWAPaths.xwa2_newsletter_metadata
+            ).then(parseNewsletterMetadata);
+        },
         newsletterFollow: (jid) => {
             return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2);
         },
@@ -224,3 +242,4 @@ export const makeNewsletterSocket = (config) => {
         }
     };
 };
+    

package/lib/Utils/bot-capabilities.js

@@ -0,0 +1,84 @@
+import { proto } from '../../WAProto/index.js';
+
+/**
+ * Numeric capability values exposed by WAProto.BotCapabilityMetadata.
+ * Keep this derived from the generated protobuf so callers cannot drift from
+ * the checked-in schema.
+ */
+export const BotCapabilityType = proto.BotCapabilityMetadata.BotCapabilityType;
+
+const capabilityNames = new Set(
+    Object.keys(BotCapabilityType).filter(name => Number.isNaN(Number(name)))
+);
+
+/** Normalize enum names/numbers and reject unknown capability values. */
+export const normalizeBotCapabilities = (capabilities = []) => {
+    if (!Array.isArray(capabilities)) {
+        throw new TypeError('capabilities must be an array');
+    }
+    const values = capabilities.map(capability => {
+        if (typeof capability === 'string') {
+            if (!capabilityNames.has(capability)) {
+                throw new TypeError(`Unknown bot capability: ${capability}`);
+            }
+            return BotCapabilityType[capability];
+        }
+        if (Number.isInteger(capability) && BotCapabilityType[capability] !== undefined) {
+            return capability;
+        }
+        throw new TypeError(`Invalid bot capability: ${String(capability)}`);
+    });
+    return [...new Set(values)];
+};
+
+export const buildBotCapabilityMetadata = (capabilities = []) => ({
+    capabilities: normalizeBotCapabilities(capabilities)
+});
+
+/**
+ * Build the canonical wrapper used by WhatsApp's bot rich-response messages.
+ * The capability list is deliberately explicit; unknown or duplicate values
+ * are never put on the wire.
+ */
+export const buildBotRichResponse = ({
+    text,
+    submessages,
+    capabilities = [],
+    botMetadata = {},
+    botJid = '867051314767696@bot',
+    richResponse = {}
+} = {}) => {
+    const resolvedSubmessages = submessages || (text == null ? [] : [{
+        messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT,
+        messageText: String(text)
+    }]);
+    return {
+        messageContextInfo: {
+            botMetadata: {
+                ...botMetadata,
+                capabilityMetadata: buildBotCapabilityMetadata(capabilities)
+            }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+                    submessages: resolvedSubmessages,
+                    ...richResponse,
+                    contextInfo: {
+                        isForwarded: true,
+                        forwardingScore: 1,
+                        forwardedAiBotMessageInfo: { botJid },
+                        forwardOrigin: 4,
+                        ...(richResponse.contextInfo || {})
+                    }
+                }
+            }
+        }
+    };
+};
+
+export const capability = (name) => {
+    if (!capabilityNames.has(name)) throw new TypeError(`Unknown bot capability: ${name}`);
+    return BotCapabilityType[name];
+};

package/lib/Utils/games/miniapp.js

@@ -0,0 +1,5 @@
+/** Generate the attached interactive mini-app HTML game. */
+export const generateMiniAppHtml = (options = {}) => {
+    const html = "<style>*{-webkit-tap-highlight-color:transparent;-webkit-user-select:none;user-select:none;-webkit-touch-callout:none}</style>\n<body style=\"margin:0;background:transparent;font-family:Arial,sans-serif;color:#eee;touch-action:manipulation;cursor:pointer\">\n<div style=\"width:100%;max-width:620px;margin:auto;padding:16px;box-sizing:border-box\">\n<div style=\"background:rgba(255,255,255,.06);backdrop-filter:blur(14px);-webkit-backdrop-filter:blur(14px);border:1px solid rgba(255,255,255,.15);border-radius:16px;overflow:hidden;box-shadow:0 8px 32px rgba(0,0,0,.35)\">\n<div style=\"padding:18px 20px;border-bottom:1px solid rgba(255,255,255,.12);display:flex;justify-content:space-between;align-items:center\">\n<div><div style=\"font-size:11px;letter-spacing:1.5px;color:rgba(255,255,255,.45)\">𝑶𝒓𝒊𝒈𝒊𝒏✦</div><div style=\"font-size:21px;font-weight:bold;color:#fff\">mini-app</div></div>\n<div style=\"text-align:right\"><div id=\"score\" style=\"font-size:18px;font-weight:bold;color:#fff;text-shadow:0 0 10px rgba(108,92,231,.85);transition:transform .15s\">00000</div><div id=\"best\" style=\"font-size:10px;color:rgba(255,255,255,.4);margin-top:2px\">BEST 00000</div></div>\n</div>\n<div style=\"padding:18px\">\n<canvas id=\"game\" width=\"560\" height=\"190\" style=\"width:100%;height:auto;background:rgba(255,255,255,.03);border:1px solid rgba(255,255,255,.12);border-radius:12px;display:block\"></canvas>\n<div id=\"status\" style=\"text-align:center;margin-top:10px;font-size:12px;color:rgba(255,255,255,.55)\">Velocità 5.0x</div>\n</div></div></div>\n<script>\nconst c=document.getElementById('game'),x=c.getContext('2d'),scoreEl=document.getElementById('score'),bestEl=document.getElementById('best'),statusEl=document.getElementById('status');\nconst GY=170;\nlet d,o,clouds,particles,ambient,trail,score,best=0,speed,gameOver,last,shake,flash,runT,spawnTimer,milestone,squash;\nfunction loadBest(){\nlet vals=[];\ntry{let v=localStorage.getItem('dino_best');if(v)vals.push(parseInt(v,10))}catch(e){}\ntry{let v=sessionStorage.getItem('dino_best');if(v)vals.push(parseInt(v,10))}catch(e){}\ntry{let m=document.cookie.match(/(?:^|;\\s*)dino_best=(\\d+)/);if(m)vals.push(parseInt(m[1],10))}catch(e){}\nreturn vals.length?Math.max(...vals.filter(v=>!isNaN(v))):0\n}\nfunction saveBest(v){\nlet val=String(Math.floor(v));\ntry{localStorage.setItem('dino_best',val)}catch(e){}\ntry{sessionStorage.setItem('dino_best',val)}catch(e){}\ntry{document.cookie='dino_best='+val+';max-age=31536000;path=/'}catch(e){}\ntry{\nlet rq=indexedDB.open('dino_db',1);\nrq.onupgradeneeded=()=>{rq.result.createObjectStore('kv')};\nrq.onsuccess=()=>{try{rq.result.transaction('kv','readwrite').objectStore('kv').put(val,'dino_best')}catch(e){}}\n}catch(e){}\n}\nfunction loadBestAsync(cb){\ntry{\nlet rq=indexedDB.open('dino_db',1);\nrq.onupgradeneeded=()=>{rq.result.createObjectStore('kv')};\nrq.onsuccess=()=>{\ntry{\nlet gr=rq.result.transaction('kv','readonly').objectStore('kv').get('dino_best');\ngr.onsuccess=()=>{if(gr.result)cb(parseInt(gr.result,10))}\n}catch(e){}\n}\n}catch(e){}\n}\nbest=loadBest();\nloadBestAsync(v=>{if(!isNaN(v)&&v>best){best=v;bestEl.textContent='BEST '+String(Math.floor(best)).padStart(5,'0')}});\nfunction reset(){\nd={x:55,y:132,w:27,h:30,vy:0,jumping:false};\no=[];\nclouds=[{x:120,y:32,w:44,s:.35},{x:300,y:52,w:60,s:.22},{x:460,y:26,w:36,s:.4},{x:560,y:70,w:50,s:.18}];\nparticles=[];\ntrail=[];\nif(!ambient){ambient=[];for(let i=0;i<18;i++)ambient.push({x:Math.random()*c.width,y:Math.random()*c.height,r:.5+Math.random()*1.5,vx:.1+Math.random()*.3,ph:Math.random()*10})}\nscore=0;speed=5;gameOver=false;last=0;shake=0;flash=0;runT=0;milestone=0;squash=1;\nspawnTimer=70+Math.random()*30;\nbestEl.textContent='BEST '+String(Math.floor(best)).padStart(5,'0');\nstatusEl.textContent='Speed 5.0x'\n}\nfunction burst(px,py,n,col,spd){for(let i=0;i<n;i++)particles.push({x:px,y:py,vx:(Math.random()-.5)*spd,vy:-Math.random()*spd,life:1,col,size:2+Math.random()*2})}\nfunction jumpDino(){\nif(gameOver){reset();return}\nif(!d.jumping){d.jumping=true;d.vy=-13;squash=.7;burst(d.x+13,d.y+30,10,'255,255,255',4)}\n}\nfunction cactus(){\nlet h=24+Math.random()*24;\no.push({x:c.width+20,y:GY-h,w:16+Math.random()*6,h});\nif(Math.random()<.22){o.push({x:c.width+20+34+Math.random()*10,y:GY-(20+Math.random()*18),w:16,h:20+Math.random()*18})}\n}\nfunction hit(a,b){return a.x+4<b.x+b.w&&a.x+a.w-4>b.x&&a.y+4<b.y+b.h&&a.y+a.h>b.y}\nfunction drawTrail(){\ntrail.forEach((p,i)=>{x.fillStyle='rgba(108,92,231,'+(.25*(i/trail.length))+')';x.fillRect(p.x,p.y,27,30)})\n}\nfunction drawDino(){\nx.save();\nlet cx=d.x+13,cy=d.y+30;\nx.translate(cx,cy);\nx.scale(1/squash,squash);\nx.translate(-cx,-cy);\nlet legOff=d.jumping?0:Math.sin(runT*.5)*5;\nx.fillStyle='#eaeaea';\nx.fillRect(d.x,d.y,27,30);\nx.fillRect(d.x+22,d.y+5,13,18);\nx.fillStyle='#6c5ce7';\nx.fillRect(d.x+29,d.y+8,4,4);\nx.fillStyle='#eaeaea';\nx.fillRect(d.x+5,d.y+30,6,8+legOff);\nx.fillRect(d.x+20,d.y+30,6,8-legOff);\nx.restore()\n}\nfunction drawCactus(q){\nx.save();\nx.shadowColor='rgba(255,90,90,.35)';x.shadowBlur=10;\nx.fillStyle='#e17a7a';\nx.fillRect(q.x,q.y,q.w,q.h);\nx.fillRect(q.x-7,q.y+10,7,6);\nx.fillRect(q.x-7,q.y+4,6,12);\nx.fillRect(q.x+q.w,q.y+18,7,6);\nx.fillRect(q.x+q.w+1,q.y+12,6,12);\nx.restore()\n}\nfunction drawParticles(){\nparticles.forEach(p=>{x.fillStyle='rgba('+p.col+','+Math.max(p.life,0)+')';x.fillRect(p.x,p.y,p.size,p.size)})\n}\nfunction drawAmbient(){\nambient.forEach(p=>{let a=.15+Math.sin(runT*.05+p.ph)*.1;x.fillStyle='rgba(180,160,255,'+a+')';x.beginPath();x.arc(p.x,p.y,p.r,0,7);x.fill()})\n}\nfunction draw(){\nx.clearRect(0,0,c.width,c.height);\nx.save();\nif(shake>0)x.translate((Math.random()-.5)*shake,(Math.random()-.5)*shake);\ndrawAmbient();\nx.fillStyle='rgba(255,255,255,.35)';\nclouds.forEach(q=>{let b=Math.sin(runT*.03+q.x)*2;x.fillRect(q.x,q.y+b,q.w,5);x.fillRect(q.x+10,q.y+b-5,q.w*.45,10)});\nx.strokeStyle='rgba(255,255,255,.25)';\nx.lineWidth=2;\nx.setLineDash([10,8]);\nx.lineDashOffset=-runT*speed*.6;\nx.beginPath();x.moveTo(0,GY);x.lineTo(c.width,GY);x.stroke();\nx.setLineDash([]);\ndrawTrail();\ndrawDino();\no.forEach(drawCactus);\ndrawParticles();\nif(flash>0){x.fillStyle='rgba(255,60,60,'+(flash*.35)+')';x.fillRect(0,0,c.width,c.height)}\nx.restore();\nif(gameOver){\nx.fillStyle='rgba(15,15,25,.55)';x.fillRect(0,0,c.width,c.height);\nx.fillStyle='#fff';x.textAlign='center';\nx.font='bold 24px Arial';x.fillText('GAME OVER',c.width/2,85);\nx.font='14px Arial';x.fillText('Tocca per giocare di nuovo',c.width/2,112);\nx.textAlign='left'\n}\n}\nfunction loop(t){\nif(!last)last=t;\nlet dt=Math.min((t-last)/16.67,2);\nlast=t;\nrunT+=dt;\nif(!gameOver){\nd.y+=d.vy*dt;d.vy+=.75*dt;\nif(d.y>=132){\nif(d.jumping){burst(d.x+13,GY,10,'255,255,255',3.5);squash=1.35}\nd.y=132;d.vy=0;d.jumping=false\n}\nif(d.jumping)trail.push({x:d.x,y:d.y});\nif(trail.length>6)trail.shift();\nif(!d.jumping)trail.length=0;\nsquash+=(1-squash)*.18*dt;\nif(!d.jumping&&Math.floor(runT)%8===0&&Math.random()<.4)burst(d.x+6,GY-2,1,'255,255,255',1.5);\nambient.forEach(p=>{p.x-=p.vx*dt;if(p.x<-4)p.x=c.width+4});\nspawnTimer-=dt;\nif(spawnTimer<=0){cactus();spawnTimer=Math.max(38,62-speed*1.4)+Math.random()*30}\no.forEach(q=>q.x-=speed*dt);\no=o.filter(q=>q.x>-40);\nclouds.forEach(q=>{q.x-=q.s*dt;if(q.x<-80)q.x=c.width+Math.random()*100});\nparticles.forEach(p=>{p.x+=p.vx*dt;p.y+=p.vy*dt;p.vy+=.3*dt;p.life-=.03*dt});\nparticles=particles.filter(p=>p.life>0);\nspeed=Math.min(11,speed+.0018*dt);\nscore+=dt*.6;\nif(score>best)best=score;\nif(Math.floor(score/500)>milestone){\nmilestone=Math.floor(score/500);\nscoreEl.style.transform='scale(1.35)';\nsetTimeout(()=>scoreEl.style.transform='scale(1)',150)\n}\nscoreEl.textContent=String(Math.floor(score)).padStart(5,'0');\nbestEl.textContent='BEST '+String(Math.floor(best)).padStart(5,'0');\nstatusEl.textContent='Speed '+speed.toFixed(1)+'x';\nfor(const q of o)if(hit(d,q)){\ngameOver=true;shake=14;flash=1;\nsaveBest(best);\nburst(d.x+13,d.y+15,18,'255,90,90',5)\n}\n}\nif(shake>0)shake=Math.max(0,shake-.6*dt);\nif(flash>0)flash=Math.max(0,flash-.05*dt);\ndraw();\nrequestAnimationFrame(loop)\n}\ndocument.addEventListener('pointerdown',e=>{e.preventDefault();jumpDino()});\ndocument.addEventListener('keydown',e=>{if(e.code==='Space'){e.preventDefault();jumpDino()}});\nreset();\nrequestAnimationFrame(loop);\n</script></body>";
+    return options.title ? html.replace('mini-app', String(options.title)) : html;
+};

package/lib/Utils/index.js

@@ -6,6 +6,7 @@ export * from './messages-media.js';
 export * from './rich-message-utils.js';
 export * from './meta-compositing.js';
 export * from './bot-planning-replay.js';
+export * from './bot-capabilities.js';
 export * from './welcome-flow.js';
 export * from './message-composer.js';
 export * from './consumer-application.js';
@@ -38,3 +39,6 @@ export * from './native-flow.js';
 export * from './view-once-utils.js';
 export * from './website-preview.js';
 export * from './portable-compat.js';
+export * from './games/miniapp.js';
+export { prepareVerticalAlbumMessage } from './rich-message-utils.js';
+export { prepareAIRichCommandMenu, prepareVideoGridMessage } from './rich-message-utils.js';

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

@@ -152,6 +152,64 @@ export const buildAdditionalBotMetadataContext = (submessages) => {
     }
     return { sources, mediaDetailsMetadataList };
 }
+export const prepareVideoGridMessage = ({ videos = [], verificationMetadata } = {}) => {
+    if (!Array.isArray(videos) || videos.length < 2) {
+        throw new Error('Video grid requires at least two videos');
+    }
+    const primitives = videos.map((video) => {
+        const url = typeof video === 'string' ? video : (video?.url || video?.videoUrl || video?.reelsUrl || '');
+        if (!url) throw new Error('Each video-grid item requires a video URL');
+        const item = typeof video === 'string' ? {} : video;
+        return {
+            post_id: item.postId == null ? undefined : String(item.postId),
+            reels_url: url,
+            reels_title: item.title,
+            thumbnail_url: item.thumbnailUrl || item.thumbnail,
+            creator: item.creator,
+            avatar_url: item.avatarUrl,
+            content_hash: item.contentHash,
+            likes_count: item.likes,
+            comments_count: item.comments,
+            shares_count: item.shares,
+            is_verified: item.isVerified,
+            source_app: item.sourceApp,
+            video_delivery_response: {
+                progressive_urls: (item.progressiveUrls || []).map((value) => ({
+                    progressive_url: value,
+                    __typename: 'GenAIProgressiveUrlResponse'
+                })),
+                dash_manifests: (item.dashManifests || []).map((value) => ({
+                    manifest_xml: value,
+                    __typename: 'GenAIDashManifestResponse'
+                })),
+                __typename: 'GenAIVideoDeliveryResponse'
+            },
+            __typename: 'GenAIVideoPrimitive'
+        };
+    });
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+            view_model: {
+                primitives,
+                __typename: 'GenAIGridLayoutViewModel'
+            }
+        }]
+    };
+    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,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
+
 export const prepareRichResponseMessage = (content) => {
     const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noDonation, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
     let submessages = [];
@@ -444,6 +502,78 @@ export const wrapToBotForwardedMessage = (richResponseMessage) => ({
  * @param {{text?: string, label?: string, alignment?: 'END'|'START'|'CENTER'}} options
  * @returns {{messageContextInfo: object, botForwardedMessage: object}}
  */
+/** Build the A2UI interactive command menu used by the full-size card layout. */
+/** Build the manually serialized AIRich command menu shown in the screenshot. */
+export const prepareAIRichCommandMenu = ({ image, title = 'CODY AI', subtitle = '', code = '', rows = [], buttons = [], footer = 'Developed by - CODY AI', latexImage, latexExpression = '' } = {}) => {
+    if (!image) throw new Error('AIRich command menu requires an image URL');
+    if (!Array.isArray(rows)) throw new Error('AIRich command-menu rows must be an array');
+    if (!Array.isArray(buttons)) throw new Error('AIRich command-menu buttons must be an array');
+    const safeRows = rows.map((row, index) => ({ command: String(row?.[0] ?? row?.command ?? `command_${index + 1}`), description: String(row?.[1] ?? row?.description ?? '') }));
+    const table = ['Command | Function', '--- | ---', ...safeRows.map((row) => `${row.command} | ${row.description}`)].join('\n');
+    const inlineEntities = latexImage ? [{ key: 'NGA', metadata: { latex_expression: String(latexExpression), latex_image: { url: String(latexImage), width: 400, height: 400 }, font_height: 83.333, padding: 15, __typename: 'GenAILatexItem' } }] : [];
+    const text = [String(title), subtitle && String(subtitle), code && `Code: ${String(code)}`, '## Command List', table, footer && String(footer)].filter(Boolean).join('\n');
+    const imagePrimitive = { __typename: 'GenAIImagePrimitive', preview_image: { __typename: 'GenAIMediaItem', mime_type: 'image/png', url: String(image) }, full_image: { __typename: 'GenAIMediaItem', mime_type: 'image/png', url: String(image) } };
+    const ctas = buttons.map((button, index) => ({ label: String(button?.text || button?.label || `Button ${index + 1}`), state: 'PENDING', kind: 'OTHER', tool_call_id: String(button?.id || `airich_menu_${index + 1}`), toast: { label: String(button?.toast || ''), __typename: 'GenAIExtWidgetToast' }, __typename: 'GenAI3PExtWidgetCTA' }));
+    const footerPrimitives = buttons.map((button, index) => ({ cta_text: String(button?.text || button?.label || `Button ${index + 1}`), cta_type: 'OPEN_URL', cta_url: String(button?.url || ''), __typename: 'GenAIFooterActionPrimitive' }));
+    footerPrimitives.push({ cta_text: '☷ OPEN MENU', cta_type: 'OPEN_URL', cta_url: String(buttons[0]?.url || ''), __typename: 'GenAIFooterActionPrimitive' });
+    const sections = [
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { __typename: 'GenAISingleLayoutViewModel', primitive: imagePrimitive } },
+        ...(ctas.length ? [{ __typename: 'GenAIUnifiedResponseSection', view_model: { primitives: [{ __typename: 'GenAI3PExtWidgetPrimitive', header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: 'Command List' }, body: { __typename: 'GenAIExtCalendarEventList', ctas, sections: [] } }], __typename: 'GenAIActionRowLayoutViewModel' } }] : []),
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { primitive: { text: `{{NGA}}${text}{{/NGA}}`, inline_entities: inlineEntities, __typename: 'GenAIMarkdownTextUXPrimitive' }, __typename: 'GenAISingleLayoutViewModel' } },
+        { __typename: 'GenAIUnifiedResponseSection', view_model: { primitives: footerPrimitives, __typename: 'GenAIActionRowLayoutViewModel' } }
+    ];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: text }],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: randomUUID(), sections })) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+export const prepareA2UICommandMenu = ({ imageMessage, title = 'CODY AI', rows = [], buttons = [], fallback = '' } = {}) => {
+    if (!Array.isArray(rows)) throw new Error('A2UI command-menu rows must be an array');
+    if (!Array.isArray(buttons)) throw new Error('A2UI command-menu buttons must be an array');
+    const safeRows = rows.map((row, index) => ({
+        title: String(row?.[0] ?? row?.title ?? `Command ${index + 1}`),
+        description: String(row?.[1] ?? row?.description ?? ''),
+        id: String(row?.[2] ?? row?.id ?? row?.[0] ?? `command_${index + 1}`)
+    }));
+    const safeButtons = buttons.map((button, index) => ({ id: `a2ui_button_${index + 1}`, label: String(button?.text || button?.label || `Button ${index + 1}`), url: String(button?.url || '') }));
+    const componentIds = ['title', 'divider', 'tableCard', 'footer', ...(safeButtons.length ? ['buttonRow'] : [])];
+    const components = [
+        { id: 'root', component: 'Column', align: 'center', children: componentIds },
+        { id: 'title', component: 'Text', text: String(title), variant: 'h2' },
+        { id: 'divider', component: 'Divider' },
+        { id: 'tableCard', component: 'Card', child: 'tableColumn' },
+        { id: 'tableColumn', component: 'Column', children: ['headerRow', ...safeRows.flatMap((_, index) => [`divider_${index}`, `row_${index}`])] },
+        { id: 'headerRow', component: 'Row', children: ['headerCommand', 'headerFunction'] },
+        { id: 'headerCommand', component: 'Text', text: 'Command', variant: 'h5' },
+        { id: 'headerFunction', component: 'Text', text: 'Function', variant: 'h5' },
+        ...safeRows.flatMap((row, index) => [
+            { id: `divider_${index}`, component: 'Divider' },
+            { id: `row_${index}`, component: 'Row', children: [`command_${index}`, `description_${index}`] },
+            { id: `command_${index}`, component: 'Text', text: row.title },
+            { id: `description_${index}`, component: 'Text', text: row.description }
+        ]),
+        { id: 'footer', component: 'Text', text: 'Developed by - CODY AI', variant: 'caption' }
+    ];
+    if (safeButtons.length) {
+        components.push({ id: 'buttonRow', component: 'Row', justify: 'spaceEvenly', children: safeButtons.flatMap((button, index) => [`buttonLabel_${index}`, `button_${index}`]) });
+        safeButtons.forEach((button, index) => {
+            components.push({ id: `buttonLabel_${index}`, component: 'Text', text: button.label });
+            components.push({ id: `button_${index}`, component: 'Button', child: `buttonLabel_${index}`, variant: 'primary', action: { call: 'openUrl', args: { url: button.url } } });
+        });
+    }
+    return {
+        interactiveMessage: {
+            ...(imageMessage ? { header: { imageMessage, hasMediaAttachment: true } } : {}),
+            bloksWidget: { type: 'im_a2ui', data: JSON.stringify({ version: 'v0.9', createSurface: { surfaceId: 'codex-a2ui-command-menu', catalogId: 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json', components } }), fallback: String(fallback || title) },
+            nativeFlowMessage: { messageParamsJson: JSON.stringify({ limited_time_offer: { text: String(title), url: safeButtons[0]?.url || '', copy_code: String(title), expiration_time: Date.now() * 1000 } }), buttons: [{ name: 'single_select', buttonParamsJson: JSON.stringify({ title: String(title), sections: [{ title: 'Available Commands', rows: safeRows }] }) }] }
+        }
+    };
+};
+
 export const prepareCopyToClipboardMessage = (options = {}) => {
     const text = String(options.text ?? '');
     const label = String(options.label ?? text);
@@ -474,6 +604,23 @@ export const prepareCopyToClipboardMessage = (options = {}) => {
 };
 
 /** Build a plain rich-text forwarded response. */
+/** 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);
+};
+export const prepareRichHtmlMessage = (options = {}) => {
+    const { html = '', trustedSources = [], url = '', title = 'Preview', tabHeader = 'HTML', tabs } = options;
+    const tabItems = Array.isArray(tabs) && tabs.length ? tabs : [{ id: 'tab_0', tab_header: tabHeader, html }];
+    const embeddedTabs = tabItems.map((tab, index) => ({ id: tab.id || `tab_${index}`, tab_header: tab.tab_header || tab.title || `HTML ${index + 1}`, sections: [{ __typename: 'GenAIUnifiedResponseSection', view_model: { __typename: 'GenAISingleLayoutViewModel', primitive: { __typename: 'GenAIaeacdsnwHtmlPrimitive', payload: String(tab.html ?? tab.payload ?? html).trim(), url: tab.url || url, trusted_sources: tab.trustedSources || trustedSources } } }], step_entries: [] }));
+    const unified = { response_id: randomUUID(), sections: [{ view_model: { primitive: { text: `> ${title}`, __typename: 'GenAIMarkdownTextUXPrimitive' }, __typename: 'GenAISingleLayoutViewModel' } }], embedded_screens: [{ title, content: [{ __typename: 'FOAIDNixelButtonSheets', tabs: embeddedTabs }] }] };
+    const richResponseMessage = proto.AIRichResponseMessage.create({ messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD, submessages: [{ messageType: RichSubMessageType.TEXT, messageText: `> ${title}` }], unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 } });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
 export const prepareRichTextMessage = ({ text = '' } = {}) => prepareRichResponseMessage({ contentText: String(text), noDonation: true });
 
 /** Build a rich image forwarded response using a GenAI image primitive. */
@@ -518,6 +665,63 @@ export const prepareSlotMachineMessage = async (options = {}) => {
  * The payload is useful for displaying generation progress without making any
  * network request or enabling a hidden background process.
  */
+/** Build a full-width vertical album with one large media item per row. */
+export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata } = {}) => {
+    if (!Array.isArray(items) || items.length < 2) {
+        throw new Error('Vertical album requires at least two media items');
+    }
+    const expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    const primitives = items.map((item) => {
+        const kind = item?.type || (item?.video ? 'video' : 'image');
+        if (kind === 'video') {
+            const video = item.video || item.data || item;
+            const url = typeof video === 'string' ? video.trim() : String(video?.url || video?.videoUrl || '').trim();
+            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.trim() : String(image?.sourceUrl || image?.url || '').trim();
+        if (!sourceUrl) throw new Error('Each image album item requires an image URL');
+        const previewUrl = image?.imagePreviewUrl || image?.previewUrl || sourceUrl;
+        const fullUrl = image?.imageHighResUrl || image?.highResUrl || image?.url || sourceUrl;
+        const width = image?.width || item?.width || 600;
+        const height = image?.height || item?.height || 400;
+        const mimeType = image?.mimeType || image?.mime_type || 'image/jpeg';
+        return {
+            preview_image: { url: previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            full_image: { url: fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            dark_mode_preview_image: { url: image?.darkModePreviewUrl || previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            dark_mode_full_image: { url: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
+            asset_query_status: 'FETCHED',
+            __typename: 'GenAIImagePrimitive'
+        };
+    });
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: Buffer.from(JSON.stringify({
+                response_id: randomUUID(),
+                sections: [{ view_model: { primitives, __typename: 'GenAIVStackLayoutViewModel' } }]
+            }))
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
 export const buildImaginePrimitive = ({
     mediaType = 'video',
     url = '',
@@ -543,3 +747,5 @@ export const buildImaginePrimitive = ({
         ...(estimatedMs !== undefined ? { estimated_ms: Number(estimatedMs) } : {})
     };
 };
+
+                                                                    

package/lib/Utils/source-grep.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const DEFAULT_DIRS = ['lib', 'WAProto'];
+const DEFAULT_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.d.ts', '.proto', '.md', '.json']);
+
+const walk = (directory, files) => {
+    if (!fs.existsSync(directory)) return;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) walk(fullPath, files);
+        else if (DEFAULT_EXTENSIONS.has(path.extname(entry.name))) files.push(fullPath);
+    }
+};
+
+/**
+ * Find a literal or regular-expression pattern in package source.
+ * Returns exact relative file, line, column, and matching source line.
+ */
+export const grepSource = (pattern, options = {}) => {
+    if (typeof pattern !== 'string' || !pattern.trim()) {
+        throw new TypeError('grepSource requires a non-empty search string');
+    }
+    const expression = options.regex ? new RegExp(pattern, options.flags || 'i') : null;
+    const needle = options.caseSensitive ? pattern : pattern.toLowerCase();
+    const files = [];
+    for (const relativeDir of options.dirs || DEFAULT_DIRS) walk(path.resolve(PACKAGE_ROOT, relativeDir), files);
+    if (options.includeReadme) files.push(path.resolve(PACKAGE_ROOT, 'README.md'));
+    const matches = [];
+    for (const file of files.sort()) {
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+        lines.forEach((line, index) => {
+            const found = expression ? expression.test(line) : (options.caseSensitive ? line.includes(pattern) : line.toLowerCase().includes(needle));
+            if (found) {
+                const column = expression ? Math.max(0, line.search(expression)) : (options.caseSensitive ? line.indexOf(pattern) : line.toLowerCase().indexOf(needle));
+                matches.push({ file: path.relative(PACKAGE_ROOT, file), line: index + 1, column: column + 1, text: line.trim() });
+            }
+            if (expression) expression.lastIndex = 0;
+        });
+    }
+    return matches.slice(0, Math.max(1, options.maxResults || 200));
+};
+  

package/lib/index.d.ts

@@ -162,6 +162,8 @@ export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
     /** Relay a prepared message with optional recipient/device-scoping controls. */
     relayMessage(jid: string, message: Record<string, unknown>, options?: RelayMessageOptions): Promise<unknown>;
+    /** Resolve a WhatsApp channel invite code or URL to newsletter metadata. */
+    newsletterGetInviteInfo(inviteCodeOrUrl: string): Promise<Record<string, unknown> | null>;
     deleteGroupStatus(jid: string, key: WAMessageKey): Promise<unknown>;
     /** Reports the contact and blocks it after WhatsApp accepts the report. */
     reportContact(jid: string, messageKeys?: WAMessageKey[]): Promise<unknown>;
@@ -295,9 +297,33 @@ export interface WASocket {
     /** Alias supporting multiple status recipients. */
     sendStatusMentions(content: Record<string, unknown>, jids?: string[], options?: Record<string, unknown>): Promise<unknown>;
     /** Send an experimental Gen4 / Meta-AI-style rich menu card. */
+    /** 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 Markdown content as a rich quote response. */
+    sendMarkdownQuote(jid: string, content?: { text?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a quote plus a 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 a full-width stacked AIRich album with at least two image/video URL items. */
+    sendAlbumMessage(jid: string, medias: Array<Record<string, unknown>>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the large A2UI command/function menu with an image header and URL buttons. */
+    sendA2UICommandMenu(jid: string, content?: { image?: unknown; title?: string; rows?: Array<[string, string, string?] | { title?: string; description?: string; id?: string }>; buttons?: Array<{ text?: string; label?: string; url?: string }>; fallback?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the manually serialized AIRich command card with image, Markdown, widget CTAs, and footer actions. */
+    sendAIRichCommandMenu(jid: string, content: { image: string; title?: string; subtitle?: string; code?: string; rows?: Array<[string, string] | { command?: string; description?: string }>; buttons?: Array<{ id?: string; text?: string; label?: string; url?: string; toast?: string }>; footer?: string; latexImage?: string; latexExpression?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a GenAI unified-response grid of video primitives. Requires at least two video URLs. */
+    sendVideoGridMessage(jid: string, videos: Array<string | { url?: string; videoUrl?: string; reelsUrl?: string; postId?: string | number; title?: string; thumbnailUrl?: string; thumbnail?: string; creator?: string; avatarUrl?: string; contentHash?: string; likes?: number; comments?: number; shares?: number; isVerified?: boolean; sourceApp?: string; progressiveUrls?: string[]; dashManifests?: string[] }>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send experimental bot diagnostic metadata. */
+    sendBotDiagnostics(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send experimental bot command metadata. */
+    sendBotCommand(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send an experimental bot planning/execution-plan rich response. */
+    sendBotPlanning(jid: string, content?: { text?: string; steps?: Array<string | { title?: string; name?: string; body?: string }>; queryPlan?: boolean; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send experimental resolved tool-call metadata. */
+    sendBotToolResult(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     richMenu(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a rich button-card grid. */
     sendRichButtonGrid(jid: string, grid: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Compatibility alias for sendRichButtonGrid. */
+    HoldOn(jid: string, grid: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a GenAI-style inline copy-to-clipboard rich response. */
     sendCopyButton(jid: string, content: { text: string; label?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a markdown-style interactive table with buttons. */
@@ -306,6 +332,10 @@ export interface WASocket {
     sendWhatsAppFlow(jid: string, flow: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a complete GenAI-style rich response envelope. */
     sendRichMedia(jid: string, content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Promise<{ message: unknown; messageId: string }>;
+    /** Send one tolerant rich response containing every supported section supplied in content. */
+    sendCodexMessage(jid: string, content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    /** Search package source files for a literal or regular-expression pattern. */
+    grepCode(pattern: string, options?: { regex?: boolean; flags?: string; caseSensitive?: boolean; dirs?: string[]; includeReadme?: boolean; maxResults?: number }): Array<{ file: string; line: number; column: number; text: string }>;
     /** Send a native AI image/video generation card. */
     sendRichGeneration(jid: string, content?: RichGenerationContent, quoted?: unknown, options?: Record<string, unknown>): Promise<RichGenerationResult>;
     /** Edit an existing rich generation card in place. */
@@ -332,9 +362,13 @@ export interface WASocket {
     /** Send LaTeX expressions using Codecogs PNG URLs. */
     sendLatexImage(jid: string, options?: { text?: string; expressions?: Array<Record<string, unknown> | string>; headerText?: string; footer?: string }): Promise<unknown>;
     /** Render and send HTML as a rich response. */
+    /** Send an interactive GenAI HTML screen with optional embedded tabs. */
+    sendRichHtmlMessage(jid: string, content: { html?: string; title?: string; url?: string; trustedSources?: string[]; tabHeader?: string; tabs?: Array<{ id?: string; tab_header?: string; title?: string; html?: string; payload?: string; url?: string; trustedSources?: string[] }> }, options?: Record<string, unknown>): Promise<unknown>;
     sendHtmlMessage(jid: string, content: { html: string; trustedSources?: string[] }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send the built-in HTML slot-machine payload. */
     sendSlotMachine(jid: string, options?: { title?: string; startingCredits?: number }, sendOptions?: Record<string, unknown>): Promise<unknown>;
+    /** Send the built-in interactive Codex mini-app. */
+    sendMiniApp(jid: string, options?: { title?: string; [key: string]: unknown }, sendOptions?: Record<string, unknown>): Promise<unknown>;
     /** Send a fetched website preview as an HTML rich response. */
     sendWebsitePreview(jid: string, url: string, options?: Record<string, unknown>, sendOptions?: Record<string, unknown>): Promise<unknown>;
     /** Send a lightweight HTML link-preview card. */
@@ -370,6 +404,7 @@ export declare function makeCacheManagerAuthState(store: CacheManagerStore, sess
 }>;
 
 /** Generate a self-contained local slot-machine HTML payload. */
+export declare function generateMiniAppHtml(options?: { title?: string; [key: string]: unknown }): string;
 export declare function generateSlotMachineHtml(options?: { title?: string; startingCredits?: number }): string;
 export declare function buildImaginePrimitive(options?: { mediaType?: 'image' | 'video'; url?: string; thumbnail?: string; mimeType?: string; fileLength?: number; duration?: number; status?: string; estimatedMs?: number; imagineType?: string }): Record<string, unknown>;
 export declare function parseNativeFlowResponse(message: unknown): Record<string, unknown> | null;
@@ -406,3 +441,14 @@ export declare function wrapSocket(socket: WASocket, config?: unknown): WASocket
 declare function makeWASocket(config: SocketConfig): WASocket;
 export { makeWASocket };
 export default makeWASocket;
+    
+
+export declare const BotCapabilityType: Record<string, number>;
+export declare function normalizeBotCapabilities(capabilities?: unknown[]): number[];
+export declare function buildBotCapabilityMetadata(capabilities?: unknown[]): Record<string, unknown>;
+export declare function buildBotRichResponse(options?: Record<string, unknown>): Record<string, unknown>;
+
+export declare function prepareVerticalAlbumMessage(options?: { items?: Array<Record<string, unknown>>; verificationMetadata?: Record<string, unknown> }): Record<string, unknown>;
+export declare function prepareAIRichCommandMenu(options?: { image?: string; title?: string; subtitle?: string; code?: string; rows?: Array<[string, string] | Record<string, unknown>>; buttons?: Array<Record<string, unknown>>; footer?: string; latexImage?: string; latexExpression?: string }): Record<string, unknown>;
+export declare function prepareVideoGridMessage(options?: { videos?: Array<string | Record<string, unknown>>; verificationMetadata?: Record<string, unknown> }): Record<string, unknown>;
+                                                            

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.13.13",
+   "version": "2.17.17",
    "description": "CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex, with Meta compositing, bot planning replay, welcome flow, rich messages, interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",