@codexverified/baileys 2.13.13 → 2.14.14

package/README.md

@@ -40,7 +40,7 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.13.13` |
+| Version | `2.14.14` |
 | Runtime | Node.js 20 or newer |
 | Module format | ESM, with CommonJS compatibility where supported |
 | Type declarations | Included at `lib/index.d.ts` |
@@ -54,7 +54,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.14.14.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 +623,57 @@ 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'
+})
+```
+
+
+### 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.

package/lib/Socket/messages-send.js

@@ -12,7 +12,7 @@ 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, prepareHtmlMessage, prepareRichHtmlMessage } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
 import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/website-preview.js';
 import { isViewOnceMessage, downloadViewOnceMedia, createRegularMessageFromViewOnce, parseViewOnceInfo } from '../Utils/view-once-utils.js';
@@ -1224,6 +1224,45 @@ 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);
+        },
+        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 album = medias.map((media, index) => { const normalized = media?.type && media?.data ? { [media.type]: media.data } : { ...media }; if (index === 0 && options.caption && !normalized.caption) normalized.caption = options.caption; return normalized; });
+        return socket.sendMessage(jid, { album }, options);
+        },
+        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);
+        },
+        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);
@@ -2228,6 +2267,15 @@ 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;
+    };
     socket.sendSlotMachine = async (jid, options = {}, sendOptions = {}) => {
         return socket.sendHtmlMessage(jid, { html: generateSlotMachineHtml(options) }, sendOptions);
     };

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

@@ -474,6 +474,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. */
@@ -543,3 +560,4 @@ export const buildImaginePrimitive = ({
         ...(estimatedMs !== undefined ? { estimated_ms: Number(estimatedMs) } : {})
     };
 };
+                                                                    

package/lib/index.d.ts

@@ -295,6 +295,20 @@ 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 an experimental album containing at least two image/video items. */
+    sendAlbumMessage(jid: string, medias: Array<Record<string, unknown>>, 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 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>;
@@ -332,6 +346,8 @@ 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>;
@@ -406,3 +422,4 @@ export declare function wrapSocket(socket: WASocket, config?: unknown): WASocket
 declare function makeWASocket(config: SocketConfig): WASocket;
 export { makeWASocket };
 export default makeWASocket;
+    

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.13.13",
+   "version": "2.14.14",
    "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",