plogme 2.0.5 → 2.0.7

package/README.md

@@ -625,6 +625,103 @@ await sock.sendRichLink(jid, {
 })
 ```
 
+### Instagram profile card with AI summary
+
+`sendInstagramProfile` builds the complete unified-response structure: a compact profile entity, divider, and clickable social-profile summary. The summary is encoded as an inline `GenAISocialEntityItem`, not as ordinary plain text.
+
+```js
+await sock.sendInstagramProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  subtitle: '⚉',
+  imageUrl: 'https://cdn.example/profile.png',
+  entityId: '123456',
+  entityUrl: 'https://www.instagram.com/crysnovax',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'See results'
+})
+```
+
+The same complete card and clickable summary are available for other platforms:
+
+```js
+await sock.sendFacebookProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/facebook.png',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'Open Facebook profile'
+})
+
+await sock.sendTikTokProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/tiktok.png',
+  fullName: 'CRYSNOVAX',
+  isVerified: true,
+  resultText: 'Open TikTok profile'
+})
+
+await sock.sendYouTubeProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/youtube.png',
+  fullName: 'CRYSNOVAX',
+  resultText: 'Open YouTube channel'
+})
+
+await sock.sendXProfile(jid, {
+  username: 'crysnovax',
+  title: 'CODY AI',
+  imageUrl: 'https://cdn.example/x.png',
+  fullName: 'CRYSNOVAX',
+  resultText: 'Open X profile'
+})
+```
+
+For a platform not covered by a named helper, use `sendSocialProfile` and supply the platform, entity type, and URL explicitly:
+
+```js
+await sock.sendSocialProfile(jid, {
+  platform: 'linkedin',
+  entityType: 'LINKEDIN_PROFILE',
+  username: 'crysnovax',
+  entityUrl: 'https://www.linkedin.com/in/crysnovax',
+  title: 'CODY AI',
+  resultText: 'Open LinkedIn profile'
+})
+```
+
+### Complete custom unified responses
+
+For newer WhatsApp primitives that do not yet have a dedicated helper, use `sendUnifiedResponse`. It preserves the complete `sections`, `view_model`, `primitives`, and inline entity objects you provide.
+
+```js
+await sock.sendUnifiedResponse(jid, {
+  sections: [
+    {
+      view_model: {
+        primitives: [
+          {
+            __typename: 'GenAIQueryPlanPrimitive',
+            title: 'Query plan',
+            steps: [
+              { title: 'Search', status: 'PLANNED' },
+              { title: 'Summarize', status: 'PLANNED' }
+            ]
+          }
+        ],
+        __typename: 'GenAIActionRowLayoutViewModel'
+      }
+    }
+  ]
+})
+```
+
+This path is useful for protocol structures that are already present in `WAProto` but are not yet normalized by a named convenience builder. It sends the payload through normal WhatsApp message generation before relay.
+
 ### Rich tables, lists, code, and LaTeX
 
 ```js
@@ -1193,6 +1290,98 @@ await sock.sendBotToolResult(jid, {
   resolutionData: { status: 'success', value: 42 }
 })
 ```
+### Proto-backed map, prompts, sources, dynamic media, and transcripts
+These helpers expose fields explicitly present in the generated `WAProto` schema. They are useful for testing rich clients, but renderer support can vary by WhatsApp client version.
+
+#### Map cards
+```js
+await sock.sendRichMap(jid, {
+  centerLatitude: 6.5244,
+  centerLongitude: 3.3792,
+  latitudeDelta: 0.12,
+  longitudeDelta: 0.1,
+  showInfoList: true,
+  annotations: [
+    {
+      latitude: 6.53,
+      longitude: 3.38,
+      title: 'Lagos',
+      body: 'Nigeria'
+    }
+  ]
+})
+```
+
+#### Suggested prompts
+```js
+await sock.sendBotPromptSuggestions(jid, {
+  text: 'Choose a follow-up',
+  suggestions: ['Summarize this', 'Translate this', 'Explain further'],
+  selectedPromptIndex: 1,
+  selectedPromptId: 'translate'
+})
+```
+
+#### Search/source metadata
+Provider values follow `WAProto.BotSourcesMetadata.BotSourceItem.SourceProvider`:
+`0 = UNKNOWN`, `1 = BING`, `2 = GOOGLE`, `3 = SUPPORT`, `4 = OTHER`.
+```js
+await sock.sendBotSources(jid, {
+  text: 'Here are the relevant sources:',
+  sources: [{
+    provider: 2,
+    url: 'https://example.com/docs',
+    query: 'baileys proto',
+    title: 'Documentation',
+    citationNumber: 1,
+    faviconUrl: 'https://example.com/favicon.ico'
+  }]
+})
+```
+
+#### Dynamic image/GIF metadata
+This sends the Proto `AIRichResponseDynamicMetadata` submessage. `type` may be `IMAGE` or `GIF`.
+```js
+await sock.sendRichDynamicMedia(jid, {
+  type: 'GIF',
+  url: 'https://example.com/animation.gif',
+  version: 2,
+  loopCount: 3
+})
+
+await sock.sendRichDynamicMedia(jid, {
+  type: 'IMAGE',
+  url: 'https://example.com/image.jpg',
+  version: 1
+})
+```
+
+#### PTT transcript metadata
+Use this for a caller-provided push-to-talk/voice transcript. The helper does not transcribe audio itself.
+```js
+await sock.sendBotPttTranscript(jid, {
+  text: 'Voice transcript',
+  transcript: 'Hello, this text came from a voice message.'
+})
+```
+
+All of these methods return the generated message object. For client-side testing, inspect `botForwardedMessage.message.richResponseMessage` and `messageContextInfo.botMetadata` before checking how the WhatsApp app renders the message.
+### Planning metadata and tool results
+`sendBotPlan` serializes the generated `BotProgressIndicatorMetadata` structure and advertises the `AGENTIC_PLANNING` and `QUERY_PLAN` capabilities defined in `WAProto`. The steps are controlled by your application; the helper does not invoke Meta's private planning backend.
+
+```js
+await sock.sendBotPlan(jid, {
+  title: 'Deployment plan',
+  text: 'I will check, deploy, and verify the service.',
+  steps: [
+    { title: 'Health check', description: 'Check the API and database', status: 'planned' },
+    { title: 'Deploy', description: 'Publish the verified build', status: 'executing' },
+    { title: 'Verify', description: 'Confirm the public endpoint', status: 'finished' }
+  ]
+})
+```
+
+`sendBotToolResult` carries the resolved tool-call metadata and advertises `QUERY_PLAN` so a tool result can be associated with a planning flow. It does not execute the tool. Your application must validate the tool name, arguments, permissions, and result before calling it.
 
 These methods do not provide Meta's private verification credentials and must not be used to impersonate a first-party Meta AI message.
 

package/lib/Defaults/index.js

@@ -10,7 +10,7 @@ export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
 export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
 export const DEF_CALLBACK_PREFIX = 'CB:';
 export const DEF_TAG_PREFIX = 'TAG:';
-export const DONATE_URL = 'https://web.crysnovax.link'; // 
+export const DONATE_URL = 'https://pair.crysnovax.link'; //
 export const LIBRARY_NAME = 'crysnovax/bailey';
 export const PHONE_CONNECTION_CB = 'CB:Pong';
 export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);

package/lib/Socket/chats.js

@@ -1863,6 +1863,9 @@ export const makeChatsSocket = (config) => {
         getUserDisclosures,
         acceptTosNotice,
         reportSpam,
+        reportUser,
+        reportMessage,
+        reportAndBlockUser,
         toggleGroupHistory,
         getOptOutList,
         signPrivateCredential,

package/lib/Socket/messages-send.js

@@ -5,7 +5,7 @@ import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { prepareRichMenuMessage, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareInstagramProfileMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
+import { prepareRichMenuMessage, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareInstagramProfileMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareSocialProfileMessage, prepareUnifiedResponseMessage, prepareRichMapMessage, prepareBotPromptSuggestionsMessage, prepareBotSourcesMessage, prepareRichDynamicMediaMessage, prepareBotPttTranscriptMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, attachBotVerificationProofs, hasVerifiableProofs } 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/games/website-preview.js';
@@ -2370,6 +2370,141 @@ export const makeMessagesSocket = (config) => {
         }
         return fullMsg;
     };
+    const sendSocialProfile = async (methodName, jid, content, options, prepare) => {
+        if (!jid) throw new Boom(`${methodName} requires a target JID`, { statusCode: 400 });
+        const wrapped = prepare(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
+        });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+    socket.sendSocialProfile = async (jid, content = {}, options = {}) => sendSocialProfile('sendSocialProfile', jid, content, options, prepareSocialProfileMessage);
+    socket.sendInstagramProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendInstagramProfile',
+        jid,
+        { ...content, platform: 'instagram', entityType: content.entityType || 'IG_PROFILE', entityUrl: content.entityUrl || `https://www.instagram.com/${content.username || ''}` },
+        options,
+        prepareInstagramProfileMessage
+    );
+    socket.sendFacebookProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendFacebookProfile', jid,
+        { ...content, platform: 'facebook', entityType: content.entityType || 'FB_PROFILE', entityUrl: content.entityUrl || `https://www.facebook.com/${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendTikTokProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendTikTokProfile', jid,
+        { ...content, platform: 'tiktok', entityType: content.entityType || 'TIKTOK_PROFILE', entityUrl: content.entityUrl || `https://www.tiktok.com/@${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendYouTubeProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendYouTubeProfile', jid,
+        { ...content, platform: 'youtube', entityType: content.entityType || 'YOUTUBE_PROFILE', entityUrl: content.entityUrl || `https://www.youtube.com/@${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendXProfile = async (jid, content = {}, options = {}) => sendSocialProfile(
+        'sendXProfile', jid,
+        { ...content, platform: 'x', entityType: content.entityType || 'X_PROFILE', entityUrl: content.entityUrl || `https://x.com/${content.username || ''}` },
+        options, prepareSocialProfileMessage
+    );
+    socket.sendUnifiedResponse = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendUnifiedResponse requires a target JID', { statusCode: 400 });
+        const wrapped = prepareUnifiedResponseMessage(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
+        });
+        if (config.emitOwnEvents) {
+            process.nextTick(async () => {
+                await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+            });
+        }
+        return fullMsg;
+    };
+    /** Sends a protocol-backed AIRich map with optional numbered annotations. */
+    socket.sendRichMap = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendRichMap requires a target JID', { statusCode: 400 });
+        const wrapped = prepareRichMapMessage(content);
+        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;
+    };
+    /** Sends BotSuggestedPromptMetadata with a rich-response text fallback. */
+    socket.sendBotPromptSuggestions = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotPromptSuggestions requires a target JID', { statusCode: 400 });
+        const wrapped = prepareBotPromptSuggestionsMessage(content);
+        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;
+    };
+    /** Sends BotSourcesMetadata for citation-aware bot responses. */
+    socket.sendBotSources = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotSources requires a target JID', { statusCode: 400 });
+        const wrapped = prepareBotSourcesMessage(content);
+        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;
+    };
+    /** Sends an experimental AIRich dynamic image/GIF submessage. */
+    socket.sendRichDynamicMedia = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendRichDynamicMedia requires a target JID', { statusCode: 400 });
+        const wrapped = prepareRichDynamicMediaMessage(content);
+        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;
+    };
+    /** Sends BotPttPromptMetadata containing a caller-provided transcript. */
+    socket.sendBotPttTranscript = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotPttTranscript requires a target JID', { statusCode: 400 });
+        const wrapped = prepareBotPttTranscriptMessage(content);
+        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;
+    };
     socket.richMenu = async (jid, content = {}, options = {}) => {
         if (!jid) throw new Boom('richMenu requires a target JID', { statusCode: 400 });
         const wrapped = prepareRichMenuMessage(content);
@@ -2535,7 +2670,7 @@ export const makeMessagesSocket = (config) => {
         const wrapped = buildBotRichResponse({
             text,
             botJid,
-            capabilities: [BotCapabilityType.AGENTIC_PLANNING],
+            capabilities: [BotCapabilityType.AGENTIC_PLANNING, BotCapabilityType.QUERY_PLAN],
             botMetadata: {
                 resolvedToolCallMetadata: {
                     toolCallId,
@@ -2547,6 +2682,58 @@ export const makeMessagesSocket = (config) => {
         await relayRichMessage(jid, fullMsg, options);
         return fullMsg;
     };
+    /**
+     * Sends a real BotProgressIndicatorMetadata planning envelope. The plan is
+     * application-controlled; this advertises the public schema capability but
+     * does not claim to invoke Meta's private planning backend.
+     */
+    socket.sendBotPlan = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendBotPlan requires a target JID', { statusCode: 400 });
+        const {
+            text = 'Execution plan',
+            title = 'Execution plan',
+            steps = [],
+            estimatedCompletionTime,
+            botJid = '867051314767696@bot'
+        } = content;
+        if (!Array.isArray(steps) || steps.length === 0) {
+            throw new Boom('sendBotPlan requires at least one step', { statusCode: 400 });
+        }
+        const planningStatus = proto.BotProgressIndicatorMetadata.BotPlanningStepMetadata.PlanningStepStatus;
+        const normalizedSteps = steps.map((step, index) => ({
+            statusTitle: String(step.title || step.name || `Step ${index + 1}`),
+            statusBody: String(step.body || step.description || ''),
+            status: step.status === 'executing' ? planningStatus.EXECUTING
+                : step.status === 'finished' || step.status === 'completed' ? planningStatus.FINISHED
+                    : planningStatus.PLANNED,
+            isReasoning: step.isReasoning === true,
+            isEnhancedSearch: step.isEnhancedSearch === true,
+            ...(Array.isArray(step.sections) ? { sections: step.sections } : {})
+        }));
+        const wrapped = {
+            messageContextInfo: { botMetadata: {
+                    capabilityMetadata: {
+                        capabilities: [
+                            proto.BotCapabilityMetadata.BotCapabilityType.AGENTIC_PLANNING,
+                            proto.BotCapabilityMetadata.BotCapabilityType.QUERY_PLAN
+                        ]
+                    },
+                    progressIndicatorMetadata: {
+                        progressDescription: title,
+                        stepsMetadata: normalizedSteps,
+                        ...(estimatedCompletionTime ? { estimatedCompletionTime } : {})
+                    }
+                } },
+            botForwardedMessage: { message: { richResponseMessage: {
+                        messageType: 1,
+                        submessages: [{ messageType: 2, messageText: text }],
+                        contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4 }
+                    } } }
+        };
+        const fullMsg = await generateWAMessageFromContent(jid, wrapped, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
     socket.sendStatus = async (content, options = {}) => {
         const statusJidList = await resolveStatusRecipients(options.statusJidList || content?.statusJidList);
         return socket.sendMessage(STATUS_JID, {

package/lib/Utils/generics.js

@@ -184,7 +184,7 @@ export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connect
  * Use to ensure your WA connection is always on the latest version
  */
 export const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://web.crysnovax.link';
+    const URL = 'https://pair.crysnovax.link';
     try {
         const response = await fetch(URL, {
             dispatcher: options.dispatcher,

package/lib/Utils/generics.js@old

@@ -179,7 +179,7 @@ export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connect
  * Use to ensure your WA connection is always on the latest version
  */
 export const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://web.crysnovax.link';
+    const URL = 'https://pair.crysnovax.link';
     try {
         const response = await fetch(URL, {
             dispatcher: options.dispatcher,

package/lib/Utils/messages.js

@@ -250,7 +250,7 @@ const prepareProductMessage = async (message, options) => {
  */
 // Lia@Changes 21-04-26 --- Enhanced prepareStickerPackMessage
 const prepareStickerPackMessage = async (message, options) => {
-    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'Website: web.crysnovax.link', description = '🏷️ crysnovax/bailey' } = message;
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'Website: pair.crysnovax.link', description = '🏷️ crysnovax/bailey' } = message;
     if (stickers.length > 60) {
         throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
     }

package/lib/Utils/messages.js[old]

@@ -271,7 +271,7 @@ const prepareProductMessage = async (message, options) => {
  */
 // Lia@Changes 21-04-26 --- Enhanced prepareStickerPackMessage
 const prepareStickerPackMessage = async (message, options) => {
-    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'Website: web.crysnovax.link', description = '🏷️ crysnovax/bailey' } = message;
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'Website: pair.crysnovax.link', description = '🏷️ crysnovax/bailey' } = message;
     if (stickers.length > 60) {
         throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
     }

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

@@ -5,6 +5,7 @@
  * If you use or copy this code, please credit my name or project. AND DO NOT CHANGE THIS NOTE
  */
 import { getRandomValues, randomUUID, randomBytes } from 'crypto';
+import { Boom } from '@hapi/boom';
 import { BOT_RENDERING_CONFIG_METADATA, DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
 import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
 import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
@@ -44,6 +45,38 @@ export const tokenizeCode = (code, language = 'javascript') => {
     }
     return blocks;
 };
+const firstImageValue = (...values) => values.find(value => value !== undefined && value !== null && String(value).length > 0);
+
+/** Normalize album image variants without downgrading full-size URLs to previews. */
+const buildRichImagePrimitive = (image = {}, expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000)) => {
+    const previewUrl = firstImageValue(image.imagePreviewUrl, image.previewUrl, image.preview_url, image.sourceUrl, image.source_url, image.url) || '';
+    const fullUrl = firstImageValue(image.imageHighResUrl, image.highResUrl, image.high_res_url, image.fullUrl, image.full_url, image.sourceUrl, image.source_url, image.url, previewUrl);
+    const darkPreviewUrl = firstImageValue(image.darkModePreviewUrl, image.dark_mode_preview_url, previewUrl);
+    const darkFullUrl = firstImageValue(image.darkModeHighResUrl, image.darkModeHighResUrl, image.dark_mode_high_res_url, image.darkModePreviewUrl, image.dark_mode_preview_url, fullUrl);
+    const width = Number(image.previewWidth || image.preview_width || image.width || 600);
+    const height = Number(image.previewHeight || image.preview_height || image.height || 400);
+    const fullWidth = Number(image.fullWidth || image.full_width || image.highResWidth || image.high_res_width || image.width || width);
+    const fullHeight = Number(image.fullHeight || image.full_height || image.highResHeight || image.high_res_height || image.height || height);
+    const darkWidth = Number(image.darkWidth || image.dark_width || fullWidth);
+    const darkHeight = Number(image.darkHeight || image.dark_height || fullHeight);
+    const mimeType = image.mimeType || image.mime_type || 'image/png';
+    const media = (url, mediaWidth, mediaHeight) => ({
+        url,
+        url_fallback: url,
+        mime_type: mimeType,
+        expiration_timestamp_ms: expiration,
+        width: mediaWidth,
+        height: mediaHeight
+    });
+    return {
+        preview_image: media(previewUrl, width, height),
+        full_image: media(fullUrl, fullWidth, fullHeight),
+        dark_mode_preview_image: media(darkPreviewUrl, darkWidth, darkHeight),
+        dark_mode_full_image: media(darkFullUrl, darkWidth, darkHeight),
+        asset_query_status: 'FETCHED',
+        __typename: 'GenAIImagePrimitive'
+    };
+};
 // Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
 export const toUnified = (submessages, uuid) => ({
     response_id: uuid || randomUUID(),
@@ -66,24 +99,7 @@ export const toUnified = (submessages, uuid) => ({
                 const imageUrls = submessage.gridImageMetadata?.imageUrls || [];
                 if (!imageUrls.length) return null;
                 const expiration = String(Date.now() + 30 * 24 * 60 * 60 * 1000);
-                const primitives = imageUrls.map(img => {
-                    const previewUrl = img.imagePreviewUrl || img.sourceUrl || '';
-                    const fullUrl = img.imageHighResUrl || img.imagePreviewUrl || img.sourceUrl || '';
-                    const width = img.width || 600;
-                    const height = img.height || 400;
-                    const darkPreviewUrl = img.darkModePreviewUrl || previewUrl;
-                    const darkFullUrl = img.darkModeHighResUrl || img.darkModePreviewUrl || fullUrl;
-                    const darkWidth = img.darkWidth || width;
-                    const darkHeight = img.darkHeight || height;
-                    return {
-                        preview_image: { url: previewUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width, height },
-                        full_image: { url: fullUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width, height },
-                        dark_mode_preview_image: { url: darkPreviewUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width: darkWidth, height: darkHeight },
-                        dark_mode_full_image: { url: darkFullUrl, mime_type: 'image/png', expiration_timestamp_ms: expiration, width: darkWidth, height: darkHeight },
-                        asset_query_status: 'FETCHED',
-                        __typename: 'GenAIImagePrimitive'
-                    };
-                });
+                const primitives = imageUrls.map(img => buildRichImagePrimitive(img, expiration));
                 return { view_model: { primitives, __typename: 'GenAIGridLayoutViewModel' } };
             }
             case RichSubMessageType.CONTENT_ITEMS: {
@@ -153,6 +169,47 @@ export const toUnified = (submessages, uuid) => ({
                     }
                 };
             }
+            case RichSubMessageType.MAP: {
+                const map = submessage.mapMetadata || {};
+                return {
+                    view_model: {
+                        primitive: {
+                            center_latitude: map.centerLatitude,
+                            center_longitude: map.centerLongitude,
+                            latitude_delta: map.latitudeDelta,
+                            longitude_delta: map.longitudeDelta,
+                            show_info_list: map.showInfoList === true,
+                            annotations: (map.annotations || []).map((annotation, index) => ({
+                                annotation_number: annotation.annotationNumber ?? index + 1,
+                                latitude: annotation.latitude,
+                                longitude: annotation.longitude,
+                                title: annotation.title || '',
+                                body: annotation.body || ''
+                            })),
+                            __typename: 'GenAIMapPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            }
+            case RichSubMessageType.DYNAMIC: {
+                const dynamic = submessage.dynamicMetadata || {};
+                const dynamicType = dynamic.type === proto.AIRichResponseDynamicMetadata.AIRichResponseDynamicMetadataType.AI_RICH_RESPONSE_DYNAMIC_METADATA_TYPE_GIF
+                    ? 'GIF'
+                    : 'IMAGE';
+                return {
+                    view_model: {
+                        primitive: {
+                            dynamic_type: dynamicType,
+                            version: dynamic.version,
+                            url: dynamic.url || '',
+                            loop_count: dynamic.loopCount,
+                            __typename: 'GenAIDynamicMediaPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            }
             case RichSubMessageType.TEXT:
                 return {
                     view_model: {
@@ -436,6 +493,7 @@ export const prepareSocialEntityMessage = ({
                                 entity_id: String(entityId ?? username ?? ''),
                                 entity_name: displayName,
                                 entity_full_name: fullName,
+                                platform: String(platform || 'GENERIC').toUpperCase(),
                                 entity_picture_url: imageUrl,
                                 entity_url: profileUrl,
                                 entity_type: resolvedType,
@@ -473,7 +531,7 @@ export const prepareSocialEntityMessage = ({
 };
 
 /** Dedicated Instagram profile card using the universal social-entity wire format. */
-export const prepareInstagramProfileMessage = (content = {}) => prepareSocialEntityMessage({
+export const prepareInstagramProfileMessage = (content = {}) => prepareSocialProfileMessage({
     ...content,
     platform: 'INSTAGRAM',
     entityType: 'IG_PROFILE',
@@ -917,23 +975,13 @@ export const prepareVerticalAlbumMessage = ({ items = [], verificationMetadata }
             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 : (image?.sourceUrl || image?.url || '');
+        const sourceUrl = typeof image === 'string' ? image : firstImageValue(
+            image?.imageHighResUrl, image?.highResUrl, image?.fullUrl,
+            image?.imagePreviewUrl, image?.previewUrl, image?.sourceUrl, image?.url
+        ) || '';
         if (!sourceUrl) throw new Error('Each image album item requires an image URL');
-        const 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/png';
-        return {
-            preview_image: { url: previewUrl, url_fallback: previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            full_image: { url: fullUrl, url_fallback: fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            dark_mode_preview_image: { url: image?.darkModePreviewUrl || previewUrl, url_fallback: image?.darkModePreviewUrl || previewUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            dark_mode_full_image: { url: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, url_fallback: image?.darkModeHighResUrl || image?.darkModePreviewUrl || fullUrl, mime_type: mimeType, expiration_timestamp_ms: expiration, width, height },
-            display_mode: 'FULL_WIDTH',
-            full_width: true,
-            asset_query_status: 'FETCHED',
-            __typename: 'GenAIImagePrimitive'
-        };
+        const primitive = buildRichImagePrimitive({ ...image, width: image?.width || item?.width, height: image?.height || item?.height }, expiration);
+        return { ...primitive, display_mode: 'FULL_WIDTH', full_width: true };
     });
     const richResponseMessage = proto.AIRichResponseMessage.create({
         submessages: [],
@@ -1002,6 +1050,217 @@ export const prepareVideoGridMessage = ({ videos = [], verificationMetadata } =
     return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
 };
 
+/**
+ * Builds a compact social-profile card used by WhatsApp's unified response
+ * renderer. The summary is an inline social entity, not ordinary plain text.
+ */
+export const prepareSocialProfileMessage = (options = {}) => {
+    const {
+        username,
+        platform = 'instagram',
+        title = 'CODY AI',
+        subtitle = '⚉',
+        imageUrl = '',
+        entityId = username,
+        entityUrl = `https://www.${platform}.com/${username || ''}`,
+        entityType = platform === 'instagram' ? 'IG_PROFILE' : `${String(platform).toUpperCase()}_PROFILE`,
+        fullName = 'NOT found',
+        isVerified = false,
+        resultText = 'See results'
+    } = options;
+    if (!username || typeof username !== 'string') {
+        throw new Boom('sendSocialProfile requires a username', { statusCode: 400 });
+    }
+    const image = imageUrl ? { url: imageUrl, mime_type: 'image/png' } : undefined;
+    const sections = [
+        {
+            view_model: {
+                primitives: [{
+                    title,
+                    subtitle,
+                    ...(image ? { image } : {}),
+                    entity_id: String(entityId || username),
+                    entity_url: entityUrl,
+                    entity_type: 'WEBSITE',
+                    action_type: 'OPEN_URL',
+                    is_verified: Boolean(isVerified),
+                    __typename: 'GenAICompactEntityPrimitive'
+                }],
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        },
+        {
+            view_model: {
+                primitives: [{ type: 'HORIZONTAL_LINE', __typename: 'GenAIDividerPrimitive' }],
+                __typename: 'GenAIVStackLayoutViewModel'
+            }
+        },
+        {
+            view_model: {
+                primitives: [
+                    { __typename: 'GenAISpacerPrimitive' },
+                    {
+                        text: `# {{social_entity_1}}${resultText}\0{{/social_entity_1}}    `,
+                        inline_entities: [{
+                            key: 'social_entity_1',
+                            metadata: {
+                                __typename: 'GenAISocialEntityItem',
+                                entity_id: username,
+                                entity_name: username,
+                                entity_full_name: fullName,
+                                platform: String(platform || 'GENERIC').toUpperCase(),
+                                entity_picture_url: imageUrl,
+                                entity_url: entityUrl,
+                                entity_type: entityType,
+                                is_verified: Boolean(isVerified)
+                            }
+                        }],
+                        __typename: 'GenAIMarkdownTextUXPrimitive'
+                    },
+                    { __typename: 'GenAISpacerPrimitive' }
+                ],
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        }
+    ];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ sections })) },
+        contextInfo: { isForwarded: true, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+
+/**
+ * Builds a generic unified-response envelope without reducing its sections to
+ * plain text. This is the extension point for newer WhatsApp primitives that
+ * are present in WAProto but do not yet have a dedicated convenience helper.
+ */
+export const prepareUnifiedResponseMessage = ({ sections = [], submessages = [], responseId = randomUUID(), contextInfo } = {}) => {
+    if (!Array.isArray(sections) || sections.length === 0) {
+        throw new Boom('sendUnifiedResponse requires at least one section', { statusCode: 400 });
+    }
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify({ response_id: responseId, sections })) },
+        contextInfo: contextInfo || { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+/** Build a protocol-backed AIRich map card with optional numbered annotations. */
+export const prepareRichMapMessage = ({ centerLatitude, centerLongitude, latitudeDelta, longitudeDelta, annotations = [], showInfoList = false, verificationMetadata } = {}) => {
+    if (!Number.isFinite(Number(centerLatitude)) || !Number.isFinite(Number(centerLongitude))) {
+        throw new Boom('prepareRichMapMessage requires centerLatitude and centerLongitude', { statusCode: 400 });
+    }
+    const submessages = [{
+        messageType: RichSubMessageType.MAP,
+        mapMetadata: {
+            centerLatitude: Number(centerLatitude),
+            centerLongitude: Number(centerLongitude),
+            ...(latitudeDelta == null ? {} : { latitudeDelta: Number(latitudeDelta) }),
+            ...(longitudeDelta == null ? {} : { longitudeDelta: Number(longitudeDelta) }),
+            showInfoList: Boolean(showInfoList),
+            annotations: (Array.isArray(annotations) ? annotations : []).map((annotation, index) => ({
+                annotationNumber: annotation.annotationNumber ?? index + 1,
+                latitude: Number(annotation.latitude),
+                longitude: Number(annotation.longitude),
+                title: String(annotation.title || ''),
+                body: String(annotation.body || '')
+            }))
+        }
+    }];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(toUnified(submessages, randomUUID()))) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
+
+/** Build a rich response carrying BotSuggestedPromptMetadata from WAProto. */
+export const prepareBotPromptSuggestionsMessage = ({ text = '', suggestions = [], selectedPromptIndex, selectedPromptId, verificationMetadata } = {}) => {
+    if (!Array.isArray(suggestions) || suggestions.length === 0) {
+        throw new Boom('prepareBotPromptSuggestionsMessage requires at least one suggestion', { statusCode: 400 });
+    }
+    const envelope = wrapToBotForwardedMessage(proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: String(text) }],
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    }), verificationMetadata);
+    envelope.messageContextInfo.botMetadata.suggestedPromptMetadata = {
+        suggestedPrompts: suggestions.map(String),
+        ...(selectedPromptIndex == null ? {} : { selectedPromptIndex: Number(selectedPromptIndex) }),
+        ...(selectedPromptId == null ? {} : { selectedPromptId: String(selectedPromptId) })
+    };
+    return envelope;
+};
+
+/** Build a rich response carrying BotSourcesMetadata for citations/search results. */
+export const prepareBotSourcesMessage = ({ text = '', sources = [], verificationMetadata } = {}) => {
+    if (!Array.isArray(sources) || sources.length === 0) {
+        throw new Boom('prepareBotSourcesMessage requires at least one source', { statusCode: 400 });
+    }
+    const envelope = wrapToBotForwardedMessage(proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: String(text) }],
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    }), verificationMetadata);
+    envelope.messageContextInfo.botMetadata.richResponseSourcesMetadata = {
+        sources: sources.map((source, index) => ({
+            provider: source.provider ?? proto.BotSourcesMetadata.BotSourceItem.SourceProvider.OTHER,
+            thumbnailCdnUrl: source.thumbnailCdnUrl || source.thumbnailUrl || '',
+            sourceProviderUrl: source.sourceProviderUrl || source.url || '',
+            sourceQuery: source.sourceQuery || source.query || '',
+            faviconCdnUrl: source.faviconCdnUrl || source.faviconUrl || '',
+            citationNumber: source.citationNumber ?? index + 1,
+            sourceTitle: source.sourceTitle || source.title || ''
+        }))
+    };
+    return envelope;
+};
+
+/** Build an AIRich dynamic image/GIF submessage from WAProto metadata. */
+export const prepareRichDynamicMediaMessage = ({ url = '', type = 'IMAGE', version = 1, loopCount, verificationMetadata } = {}) => {
+    if (!url || typeof url !== 'string') throw new Boom('prepareRichDynamicMediaMessage requires a URL', { statusCode: 400 });
+    const dynamicTypes = proto.AIRichResponseDynamicMetadata.AIRichResponseDynamicMetadataType;
+    const normalizedType = String(type).toUpperCase();
+    const dynamicMetadata = {
+        type: normalizedType === 'GIF'
+            ? dynamicTypes.AI_RICH_RESPONSE_DYNAMIC_METADATA_TYPE_GIF
+            : dynamicTypes.AI_RICH_RESPONSE_DYNAMIC_METADATA_TYPE_IMAGE,
+        version: Number(version),
+        url,
+        ...(loopCount == null ? {} : { loopCount: Number(loopCount) })
+    };
+    const submessages = [{ messageType: RichSubMessageType.DYNAMIC, dynamicMetadata }];
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(toUnified(submessages, randomUUID()))) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage, verificationMetadata);
+};
+
+/** Build a rich response carrying the exact BotPttPromptMetadata transcript field. */
+export const prepareBotPttTranscriptMessage = ({ text = '', transcript = '', verificationMetadata } = {}) => {
+    if (!transcript || typeof transcript !== 'string') {
+        throw new Boom('prepareBotPttTranscriptMessage requires a transcript', { statusCode: 400 });
+    }
+    const envelope = wrapToBotForwardedMessage(proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: String(text || transcript) }],
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    }), verificationMetadata);
+    envelope.messageContextInfo.botMetadata.pttPromptMetadata = { transcript };
+    return envelope;
+};
+
 export const prepareRichResponseMessage = (content) => {
     const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noDonation, noHeading, posts, products, reels, sources: sourceInputs, suggested, richResponse, table, tapLinkUrl, title, verificationMetadata } = content;
     let submessages = [];

package/lib/index.d.ts

@@ -278,6 +278,67 @@ export interface SocialEntityContent {
     responseId?: string;
 }
 
+export interface RichMapAnnotation {
+    annotationNumber?: number;
+    latitude: number;
+    longitude: number;
+    title?: string;
+    body?: string;
+}
+
+export interface RichMapContent {
+    centerLatitude: number;
+    centerLongitude: number;
+    latitudeDelta?: number;
+    longitudeDelta?: number;
+    annotations?: RichMapAnnotation[];
+    showInfoList?: boolean;
+    verificationMetadata?: Record<string, unknown>;
+}
+
+export interface BotPromptSuggestionsContent {
+    text?: string;
+    suggestions: string[];
+    selectedPromptIndex?: number;
+    selectedPromptId?: string;
+    verificationMetadata?: Record<string, unknown>;
+}
+
+export interface BotSourceContent {
+    provider?: number;
+    thumbnailCdnUrl?: string;
+    thumbnailUrl?: string;
+    sourceProviderUrl?: string;
+    url?: string;
+    sourceQuery?: string;
+    query?: string;
+    faviconCdnUrl?: string;
+    faviconUrl?: string;
+    citationNumber?: number;
+    sourceTitle?: string;
+    title?: string;
+}
+
+export interface BotSourcesContent {
+    text?: string;
+    sources: BotSourceContent[];
+    verificationMetadata?: Record<string, unknown>;
+}
+
+export interface RichDynamicMediaContent {
+    url: string;
+    type?: 'IMAGE' | 'GIF' | string;
+    version?: number;
+    loopCount?: number;
+    verificationMetadata?: Record<string, unknown>;
+}
+
+export interface BotPttTranscriptContent {
+    transcript: string;
+    text?: string;
+    verificationMetadata?: Record<string, unknown>;
+}
+
 export interface AIRichCommandMenuContent {
     image: string;
     title?: string;
@@ -326,6 +387,16 @@ export interface WASocket {
     richMenu(jid: string, content?: RichMenuContent, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a provider-neutral AIRich social/entity result card. */
     sendSocialEntity(jid: string, content?: SocialEntityContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a protocol-backed AIRich map with optional numbered annotations. */
+    sendRichMap(jid: string, content: RichMapContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send BotSuggestedPromptMetadata with a rich-response text fallback. */
+    sendBotPromptSuggestions(jid: string, content: BotPromptSuggestionsContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send BotSourcesMetadata for citation-aware bot responses. */
+    sendBotSources(jid: string, content: BotSourcesContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send an experimental AIRich dynamic image/GIF submessage. */
+    sendRichDynamicMedia(jid: string, content: RichDynamicMediaContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send BotPttPromptMetadata containing a caller-provided transcript. */
+    sendBotPttTranscript(jid: string, content: BotPttTranscriptContent, options?: Record<string, unknown>): Promise<unknown>;
     /** Send the primary Instagram profile result using the universal social/entity format. */
     sendInstagramProfile(jid: string, content: SocialEntityContent, options?: Record<string, unknown>): Promise<unknown>;
     /** Send arbitrary A2UI/interactive payloads with immediate relay/edit rendering. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plogme",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Production-ready Baileys fork ⚉ with AI groups, Meta AI prompting, safe compositing fallbacks, rich responses, interactive messages, albums, newsletters, and communities — without antiban wrappers.",
   "main": "lib/index.js",
   "type": "module",