plogme 1.0.3 → 1.0.5

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1040735178];
+const version = [2, 3000, 1047412487];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';

package/lib/Socket/messages-send.js

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

package/lib/Utils/messages.js

@@ -1016,6 +1016,33 @@ export const generateWAMessageContent = async (message, options) => {
     else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
         m.requestPhoneNumberMessage = {};
     }
+    else if (hasNonNullishProperty(message, 'chatTheme')) {
+        const theme = message.chatTheme || {};
+        const themeSetting = {};
+        if (theme.animatedWallpaper) {
+            const wallpaper = theme.animatedWallpaper;
+            themeSetting.animatedWallpaper = proto.Message.ChatAnimatedWallpaper.fromObject({
+                animatedWallpaperId: wallpaper.id || wallpaper.animatedWallpaperId,
+                dimLevel: wallpaper.dimLevel ?? (wallpaper.opacity != null ? wallpaper.opacity / 100 : 0)
+            });
+        }
+        if (Object.keys(themeSetting).length) {
+            m.protocolMessage = {
+                type: proto.Message.ProtocolMessage.Type.CHAT_THEME_SETTING,
+                chatThemeSetting: proto.Message.ChatThemeSetting.fromObject(themeSetting)
+            };
+        }
+    }
+    else if (hasNonNullishProperty(message, 'newsletterFollowerInvite') ||
+        hasNonNullishProperty(message, 'newsletterFollowerInviteMessage') ||
+        hasNonNullishProperty(message, 'newsletterFollowerInviteMessageV2')) {
+        const isV2 = hasNonNullishProperty(message, 'newsletterFollowerInviteMessageV2');
+        const invite = isV2
+            ? message.newsletterFollowerInviteMessageV2
+            : (message.newsletterFollowerInvite ?? message.newsletterFollowerInviteMessage);
+        const field = isV2 ? 'newsletterFollowerInviteMessageV2' : 'newsletterFollowerInviteMessage';
+        m = { [field]: proto.Message.NewsletterFollowerInviteMessage.fromObject(invite) };
+    }
     else if (hasNonNullishProperty(message, 'limitSharing')) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.LIMIT_SHARING,
@@ -1033,6 +1060,12 @@ export const generateWAMessageContent = async (message, options) => {
             m.audioMessage.backgroundArgb = await assertColor(options.backgroundColor);
         }
     }
+    if (m.stickerMessage && hasNonNullishProperty(message, 'stickerAudio')) {
+        const audioPrepared = await prepareWAMessageMedia({ audio: message.stickerAudio, ptt: true }, options);
+        if (audioPrepared?.audioMessage) {
+            m.stickerMessage.audioMessage = audioPrepared.audioMessage;
+        }
+    }
     // Lia@Changes 30-01-26 --- Add interactive messages (buttonsMessage, listMessage, interactiveMessage, templateMessage, and carouselMessage)
     if (hasNonNullishProperty(message, 'buttons')) {
         const buttonsMessage = {
@@ -1222,18 +1255,21 @@ export const generateWAMessageContent = async (message, options) => {
                         throw new Boom('Invalid media type for carousel card', { statusCode: 400 });
                     }
                     const carouselCard = {
-                        nativeFlowMessage: prepareNativeFlowButtons(card.nativeFlow ? card : [])
+                        nativeFlowMessage: prepareNativeFlowButtons({
+                            ...card,
+                            nativeFlow: card.nativeFlow || card.buttons || []
+                        }),
+                        header: {
+                            title: card.title || '',
+                            subtitle: card.subtitle || '',
+                            hasMediaAttachment: isValidHeader
+                        }
                     };
                     if (hasOptionalProperty(card, 'text')) {
                         carouselCard.body = { text: card.text };
                     }
                     else {
                         if (hasOptionalProperty(card, 'caption')) {
-                            carouselCard.header = {
-                                title: card.title || '',
-                                subtitle: card.subtitle || '',
-                                hasMediaAttachment: isValidHeader
-                            };
                             carouselCard.body = { text: card.caption };
                         }
                         if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
@@ -1402,10 +1438,9 @@ export const generateWAMessageContent = async (message, options) => {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
         const mediaSpoiler = ['imageMessage', 'videoMessage', 'documentMessage', 'stickerMessage'].includes(messageType);
-        // View-once is the only broadly supported WhatsApp envelope that
-        // withholds the media preview until the recipient opens/downloads it.
-        // Native spoiler metadata remains available as an explicit opt-in.
-        const mediaSpoilerMode = message.mediaSpoilerMode || options?.mediaSpoilerMode || 'viewOnce';
+        // Native media spoilers use contextInfo.isSpoiler. View-once remains an
+        // explicit compatibility fallback for clients that do not render it.
+        const mediaSpoilerMode = message.mediaSpoilerMode || options?.mediaSpoilerMode || 'native';
         if (mediaSpoiler && mediaSpoilerMode === 'viewOnce') {
             m = { viewOnceMessage: { message: m } };
         }
@@ -1416,7 +1451,8 @@ export const generateWAMessageContent = async (message, options) => {
             else if (key) {
                 key.contextInfo = { isSpoiler: true };
             }
-            m = { spoilerMessage: { message: m } };
+            // `spoilerMessage` is not a field in WAProto.Message. The native
+            // representation is the media message's contextInfo.isSpoiler bit.
         }
         else if (key && typeof key.text === 'string') {
             const nativeSpoiler = message.spoilerMode === 'native' || options?.spoilerMode === 'native';

package/lib/Utils/process-message.js

@@ -138,6 +138,17 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         }
     }
     const content = normalizeMessageContent(message.message);
+    if (content?.acp2SettingMessage) {
+        const acp2Setting = message.messageContextInfo?.acp2Setting;
+        if (acp2Setting) {
+            Object.assign(chat, {
+                acp2Enabled: acp2Setting.enabled || false,
+                acp2SettingTimestamp: toNumber(acp2Setting.settingTimestamp) || toNumber(message.messageTimestamp),
+                acp2Trigger: acp2Setting.trigger,
+                acp2InitiatedByMe: acp2Setting.initiatedByMe || false
+            });
+        }
+    }
     // unarchive chat if it's a real message, or someone reacted to our message
     // and we've the unarchive chats setting on
     if ((isRealMsg || content?.reactionMessage?.key?.fromMe) && accountSettings?.unarchiveChats) {
@@ -579,4 +590,4 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         ev.emit('chats.update', [chat]);
     }
 };
-export default processMessage;
+export default processMessage;

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

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

package/lib/index.d.ts

@@ -213,21 +213,45 @@ export interface RelayMessageOptions {
     /** Retry resend target; requires a device JID and retry count. */
     participants?: { jid: string; count: number };
     retryParticipants?: { jid: string; count: number };
-    /** Keep only the target's primary device. */
+    /** Keep only the target's primary device in supported private-chat fan-out paths; not encryption. */
     isSecret?: boolean;
-    /** Skip the target's linked devices. */
+    /** Skip the target's linked devices in supported private-chat fan-out paths; enforcement is client-dependent. */
     protected?: boolean;
-    /** Keep only the sender's own devices. */
+    /** Keep only the sender's own devices in supported private-chat fan-out paths. */
     me?: boolean;
     [key: string]: unknown;
 }
 
+export interface AlbumMediaInput {
+    image?: unknown;
+    video?: unknown;
+    caption?: string;
+    [key: string]: unknown;
+}
+
+export interface AnimatedWallpaperInput {
+    id?: string;
+    animatedWallpaperId?: string;
+    dimLevel?: number;
+    opacity?: number;
+}
+
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
+    /** Send at least two image/video items as an experimental WhatsApp album. */
+    sendAlbumMessage(jid: string, medias: AlbumMediaInput[], options?: Record<string, unknown>): Promise<unknown>;
+    /** Update the connected account's WhatsApp About/profile status. */
+    updateProfileStatus(status: string): Promise<void>;
+    /** Update the connected account's profile name. */
+    updateProfileName(name: string): Promise<void>;
+    /** Set or clear the connected account's own custom label in a group. */
+    updateMemberLabel(groupJid: string, memberLabel: string): Promise<unknown>;
     /** Relay a prepared message with optional recipient/device-scoping compatibility controls. */
     relayMessage(jid: string, message: Record<string, unknown>, options?: RelayMessageOptions): Promise<unknown>;
     /** Send an experimental Meta AI-style rich menu with image, card buttons, and an optional URL footer. */
     richMenu(jid: string, content?: RichMenuContent, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send raw HTML through the experimental WhatsApp HTML primitive. */
+    sendHtmlMessage(jid: string, content: { html: string; trustedSources?: string[] }, options?: Record<string, unknown>): Promise<unknown>;
     /** Post a personal status using explicit viewers or a configured contact source/provider. */
     sendStatus(content: Omit<StatusContent, 'statusJidList'>, options?: Partial<StatusOptions> & { statusJidList?: string[] }): Promise<unknown>;
     /** Publish a status and create status-mention references for the supplied users or groups. */
@@ -238,6 +262,18 @@ export interface WASocket {
     sendWhatsAppFlow(jid: string, flow: { flowId: string; flowToken: string; cta?: string; action?: string; actionPayload?: Record<string, unknown>; mode?: string; flowMessageVersion?: string | number; metadata?: Record<string, unknown>; text?: string; footer?: string; image?: unknown; caption?: string; nativeFlowName?: string }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a rich native-flow URL CTA that opens a hosted WebView/Mini App. */
     sendRichWebview(jid: string, content: { text?: string; title?: string; footer?: string; image?: unknown; caption?: string; buttonText?: string; url: string; useWebview?: boolean; toast?: string; [key: string]: unknown }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental bot infrastructure diagnostics metadata. */
+    sendBotDiagnostics(jid: string, content?: { text?: string; botBackend?: number; toolsUsed?: string[]; isThinking?: boolean; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental bot command metadata. */
+    sendBotCommand(jid: string, content?: { text?: string; commandName?: string; commandDescription?: string; commandPrompt?: string; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich response with experimental resolved tool-call metadata. */
+    sendBotToolResult(jid: string, content?: { text?: string; toolCallId?: string; resolutionData?: unknown; resolutionDataSerialized?: string; botJid?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send Markdown text containing blockquotes in a forwarded GenAI rich response. */
+    sendMarkdownQuote(jid: string, content?: { text?: string; copyText?: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send Markdown blockquotes followed by a GenAI COPY_TO_CLIPBOARD action. */
+    sendQuoteCopy(jid: string, content: { text?: string; copyText: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send ordinary Markdown/text followed by a GenAI COPY_TO_CLIPBOARD action. */
+    sendRichTextCopy(jid: string, content: { text?: string; copyText: string; copyLabel?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a native AI image/video generation card with a GENERATING or READY state. */
     sendRichGeneration(jid: string, content?: RichGenerationContent, quoted?: unknown, options?: Record<string, unknown>): Promise<RichGenerationResult>;
     /** Edit an existing AI generation card in place using WhatsApp's type-14 edit protocol. */

package/package.json

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