@innovatorssoft/innovators-bot2 2.0.5 → 2.0.7

package/index.js

@@ -4,7 +4,6 @@ const {
     useMultiFileAuthState,
     DisconnectReason,
     fetchLatestBaileysVersion,
-    fetchLatestWaWebVersion,
     downloadMediaMessage,
     getCurrentSenderInfo,
     // JID Utilities
@@ -21,11 +20,17 @@ const {
     generateCombinedButtons,
     generateCopyCodeButton,
     generateUrlButtonMessage,
-    generateQuickReplyButtons
+    generateQuickReplyButtons,
+    StatusHelper,
+    STATUS_BACKGROUNDS,
+    STATUS_FONTS,
+    renderLatexToPng,
+    uploadUnencryptedToWA,
+    RichSubMessageType,
+    getAggregateVotesInPollMessage
 } = require('@innovatorssoft/baileys');
 
 const { Sticker, StickerTypes } = require('wa-sticker-formatter');
-
 const { Boom } = require('@hapi/boom');
 const { EventEmitter } = require('events');
 const P = require('pino');
@@ -35,7 +40,7 @@ const mime = require('mime');
 const figlet = require('figlet');
 const NodeCache = require('node-cache');
 
-process.title = 'INNOVATORS Soft WhatsApp Server 92 322 4559543'
+process.title = 'INNOVATORS Soft WhatsApp Server +447498792682'
 
 console.log(figlet.textSync('WELCOME To'))
 console.log(figlet.textSync('INNOVATORS'))
@@ -79,6 +84,7 @@ class WhatsAppClient extends EventEmitter {
         this._storeChangeCount = 0;
         this._pairingCodeTimer = null;
         this._lastStoreSave = null;
+        this.ai = config.ai === undefined ? true : config.ai;
     }
 
     /**
@@ -124,6 +130,32 @@ class WhatsAppClient extends EventEmitter {
         return jid.replace(/:\d+@/, '@');
     }
 
+    /**
+     * Internal helper to handle mentions and the "mention all" flag
+     * @param {string[]} mentions - Array of JIDs or keywords like 'all'/'@all'
+     * @param {boolean} mentionAll - Explicit mentionAll flag
+     * @returns {object} Object containing processed mentions and mentionAll flag
+     * @private
+     */
+    _handleMentions(mentions, mentionAll) {
+        let processedMentions = mentions;
+        let finalMentionAll = mentionAll;
+
+        if (mentions && Array.isArray(mentions)) {
+            processedMentions = mentions
+                .filter(jid => jid !== 'all' && jid !== '@all')
+                .map(jid => this._normalizeJid(jid));
+            if (mentions.includes('all') || mentions.includes('@all')) {
+                finalMentionAll = true;
+            }
+        }
+
+        return {
+            mentions: processedMentions,
+            mentionAll: finalMentionAll
+        };
+    }
+
     async connect() {
         try {
             if (this._connectionState === 'connecting' && this.sock) {
@@ -136,10 +168,7 @@ class WhatsAppClient extends EventEmitter {
             }
 
             const { version: baileysVersion, isLatest: baileysIsLatest } = await fetchLatestBaileysVersion();
-            const { version: waWebVersion, isLatest: waWebIsLatest } = await fetchLatestWaWebVersion();
-
             console.log('Using Baileys Version:', baileysVersion, baileysIsLatest ? ' isLatest true' : ' isLatest false');
-            console.log('Using WhatsApp Web Version:', waWebVersion, waWebIsLatest ? ' isLatest true' : ' isLatest false');
 
             const { state, saveCreds } = await useMultiFileAuthState(this.sessionName)
             const logger = P({ level: 'silent' })
@@ -148,13 +177,20 @@ class WhatsAppClient extends EventEmitter {
                 auth: state,
                 logger,
                 markOnlineOnConnect: false,
-                syncFullHistory: true,
-                getMessage: async (key) => (this.messageStore.getOriginalMessage(key))?.message,
+                syncFullHistory: false,
+                getMessage: async (key) => {
+                    const msg = this.messageStore.getOriginalMessage(key);
+                    if (!msg) {
+                        console.log(`Message not found for key: ${JSON.stringify(key)}`);
+                        return undefined;
+                    }
+                    return msg.message;
+                },
                 generateHighQualityLinkPreview: true,
                 linkPreviewImageThumbnailWidth: 192,
                 emitOwnEvents: true,
                 browser: Browsers.android('Innovators Soft'),
-                version: waWebVersion,
+                version: baileysVersion,
                 cachedGroupMetadata: async (jid) => {
                     const cached = this.groupMetadataCache.get(jid);
                     if (cached) {
@@ -291,6 +327,10 @@ class WhatsAppClient extends EventEmitter {
                 // Save message store to file immediately
                 await this.saveMessageStore();
 
+                /*console.log('-'.repeat(50));
+                console.dir(update, { depth: null });
+                console.log('-'.repeat(50));*/
+
                 try {
                     if (update.type !== 'notify' || !update.messages?.length) return;
                     const [message] = update.messages;
@@ -301,19 +341,14 @@ class WhatsAppClient extends EventEmitter {
 
                     const msg = message.message || {};
 
+                    let jid = this._normalizeJid(message.key.remoteJid);
 
-                    let jid = message.key.remoteJid;
-
-                    // Prefer PN (Phone Number) JID over LID for better compatibility
-                    // remoteJidAlt contains the alternate JID (PN if primary is LID, or vice versa)
-                    if (typeof message.key.remoteJidAlt === 'string' &&
-                        message.key.remoteJidAlt.endsWith('@s.whatsapp.net')
-                    ) {
-                        jid = message.key.remoteJidAlt;
-                    }
+                    // Keep the original technical JID as the primary identifier for Signal sessions
+                    // remoteJidAlt can be used if needed, but not to replace the primary jid for technical replies
+                    const jidAlt = this._normalizeJid(message.key.remoteJidAlt) || null;
                     // Resolve the actual sender (preferring PN over LID)
-                    const participant = message.key.participant || message.participant || null;
-                    const participantAlt = message.key.participantAlt || null;
+                    const participant = this._normalizeJid(message.key.participant || message.participant) || null;
+                    const participantAlt = this._normalizeJid(message.key.participantAlt) || null;
 
                     let sender = jid;
                     if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
@@ -352,7 +387,7 @@ class WhatsAppClient extends EventEmitter {
                         return '';
                     };
 
-                    const reply = async (text) => this.sock.sendMessage(jid, { text }, { quoted: message, ai: true });
+                    const reply = async (text) => this.sock.sendMessage(jid, { text }, { quoted: message, ai: this.ai });
 
                     // ✅ Handle status updates (stories)
                     if (jid === 'status@broadcast') {
@@ -369,7 +404,7 @@ class WhatsAppClient extends EventEmitter {
                             // Reply to status
                             reply: async (text) => {
                                 if (!sender) throw new Error('Missing participant JID');
-                                return this.sock.sendMessage(sender, { text }, { quoted: message, ai: true });
+                                return this.sock.sendMessage(sender, { text }, { quoted: message, ai: this.ai });
                             },
                             // 👍 Like (react) to status
                             like: async (emoji = '❤️') => {
@@ -388,7 +423,7 @@ class WhatsAppClient extends EventEmitter {
                                         text: emoji,
                                         key: message.key
                                     }
-                                }, { ai: true });
+                                }, { ai: this.ai });
                             }
                         });
                         return;
@@ -401,6 +436,7 @@ class WhatsAppClient extends EventEmitter {
 
                     this.emit('message', {
                         from: jid,
+                        fromAlt: jidAlt,
                         sender,
                         participant,
                         participantAlt,
@@ -424,20 +460,128 @@ class WhatsAppClient extends EventEmitter {
             // 🛡️ Anti-Delete System: Handle message revokes/deletions
             const antiDeleteHandler = createAntiDeleteHandler(this.messageStore);
 
-            this.sock.ev.on('messages.update', (updates) => {
+            this.sock.ev.on('messages.update', async (updates) => {
                 const deletedMessages = antiDeleteHandler(updates);
                 for (const info of deletedMessages) {
-                    let jid = info.key.remoteJid;
-                    if (typeof info.key.remoteJidAlt === 'string' && info.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
-                        jid = info.key.remoteJidAlt;
-                    }
+                    let jid = this._normalizeJid(info.key.remoteJid);
+                    // Use original remoteJid for technical identification
+                    const jidAlt = this._normalizeJid(info.key.remoteJidAlt) || null;
 
                     this.emit('message-deleted', {
                         jid: jid,
+                        jidAlt: jidAlt,
                         originalMessage: info.originalMessage,
                         key: info.key
                     });
                 }
+
+                // Handle Poll Updates
+                for (const updateObj of updates) {
+                    const { key, update } = updateObj;
+                    if (update.pollUpdates) {
+                        try {
+                            const pollCreation = this.messageStore.getOriginalMessage(key);
+                            if (pollCreation) {
+                                // Initialize pollUpdates array on the stored message if it doesn't exist
+                                if (!pollCreation.pollUpdates) {
+                                    pollCreation.pollUpdates = [];
+                                }
+
+                                // Merge new updates by voter JID to ensure only the latest vote per voter is stored
+                                for (const newUp of update.pollUpdates) {
+                                    const voterJid = newUp.pollUpdateMessageKey?.participant || (newUp.pollUpdateMessageKey?.fromMe ? 'me' : null);
+                                    if (voterJid) {
+                                        const normVoterJid = voterJid === 'me' ? 'me' : this._normalizeJid(voterJid);
+                                        const index = pollCreation.pollUpdates.findIndex(existing => {
+                                            const existingVoter = existing.pollUpdateMessageKey?.participant || (existing.pollUpdateMessageKey?.fromMe ? 'me' : null);
+                                            const normExisting = existingVoter === 'me' ? 'me' : this._normalizeJid(existingVoter);
+                                            return normExisting === normVoterJid;
+                                        });
+                                        if (index !== -1) {
+                                            pollCreation.pollUpdates[index] = newUp; // Replace with latest vote update from this voter
+                                        } else {
+                                            pollCreation.pollUpdates.push(newUp); // Add new voter's update
+                                        }
+                                    }
+                                }
+
+                                const pollUpdate = getAggregateVotesInPollMessage({
+                                    message: pollCreation.message || pollCreation,
+                                    pollUpdates: pollCreation.pollUpdates,
+                                });
+
+                                // Resolve JID from LID to PN for voters in the poll update
+                                const resolvedPollUpdate = await Promise.all(
+                                    pollUpdate.map(async (option) => {
+                                        const resolvedVoters = await Promise.all(
+                                            (option.voters || []).map(async (v) => {
+                                                if (v === 'me') return 'me';
+                                                return await this._resolveLidToPn(v);
+                                            })
+                                        );
+                                        return {
+                                            ...option,
+                                            voters: resolvedVoters
+                                        };
+                                    })
+                                );
+
+                                let jid = this._normalizeJid(key.remoteJid);
+                                jid = await this._resolveLidToPn(jid);
+                                const jidAlt = this._normalizeJid(key.remoteJidAlt) || null;
+
+                                // Clone key to resolve LIDs to PNs without mutating the original reference if it's read-only
+                                const resolvedKey = { ...key };
+                                if (key.remoteJid) {
+                                    resolvedKey.remoteJid = await this._resolveLidToPn(key.remoteJid);
+                                }
+                                if (key.participant) {
+                                    resolvedKey.participant = await this._resolveLidToPn(key.participant);
+                                }
+
+                                // Clone pollCreation to resolve LIDs to PNs without mutating the original store reference
+                                const resolvedPollCreation = { ...pollCreation };
+                                if (pollCreation.participant) {
+                                    resolvedPollCreation.participant = await this._resolveLidToPn(pollCreation.participant);
+                                }
+                                if (pollCreation.key) {
+                                    resolvedPollCreation.key = { ...pollCreation.key };
+                                    if (pollCreation.key.remoteJid) {
+                                        resolvedPollCreation.key.remoteJid = await this._resolveLidToPn(pollCreation.key.remoteJid);
+                                    }
+                                    if (pollCreation.key.participant) {
+                                        resolvedPollCreation.key.participant = await this._resolveLidToPn(pollCreation.key.participant);
+                                    }
+                                }
+
+                                // Extract and resolve voter JID(s) from the pollUpdates
+                                const voters = await Promise.all(
+                                    (update.pollUpdates || []).map(async (u) => {
+                                        const voterJid = u.pollUpdateMessageKey?.participant || (u.pollUpdateMessageKey?.fromMe ? 'me' : null);
+                                        if (voterJid && voterJid !== 'me') {
+                                            return await this._resolveLidToPn(this._normalizeJid(voterJid));
+                                        }
+                                        return voterJid;
+                                    })
+                                ).then(arr => arr.filter(Boolean));
+
+                                this.emit('poll-votes-update', {
+                                    jid: jid,
+                                    jidAlt: jidAlt,
+                                    voter: voters[0] || null,
+                                    voters: voters,
+                                    key: resolvedKey,
+                                    pollUpdate: resolvedPollUpdate,
+                                    pollCreationMessage: resolvedPollCreation
+                                });
+                            } else {
+                                console.log('[PollVotes] Could not find poll creation message in store for key:', key.id);
+                            }
+                        } catch (err) {
+                            console.error('[PollVotes ERROR] Error processing poll updates:', err);
+                        }
+                    }
+                }
             });
 
             // 👍 Handle message reactions
@@ -446,17 +590,16 @@ class WhatsAppClient extends EventEmitter {
 
                 try {
                     for (const reaction of reactions) {
+                        if (reaction.key?.fromMe) continue;
 
                         // Get the chat JID, preferring PN over LID
-                        let jid = reaction.key.remoteJid;
-                        if (typeof reaction.key.remoteJidAlt === 'string' &&
-                            reaction.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
-                            jid = reaction.key.remoteJidAlt;
-                        }
+                        let jid = this._normalizeJid(reaction.key.remoteJid);
+                        // Use original remoteJid for technical identification
+                        const jidAlt = this._normalizeJid(reaction.key.remoteJidAlt) || null;
 
                         // Resolve the sender (who reacted), preferring PN over LID
-                        const participant = reaction.key.participant || null;
-                        const participantAlt = reaction.key.participantAlt || null;
+                        const participant = this._normalizeJid(reaction.key.participant) || null;
+                        const participantAlt = this._normalizeJid(reaction.key.participantAlt) || null;
 
                         let sender = jid;
                         if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
@@ -471,6 +614,7 @@ class WhatsAppClient extends EventEmitter {
                         // Emit the reaction event
                         this.emit('message-reaction', {
                             from: jid,
+                            fromAlt: jidAlt,
                             sender: sender,
                             participant: participant,
                             participantAlt: participantAlt,
@@ -611,75 +755,101 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or message sending fails
      */
     async sendMessage(chatId, message, options = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
 
         let messageContent = {};
 
-        // Handle different message types
-        if (typeof message === 'string') {
+        // Check if poll is provided in message or options
+        let pollData = null;
+        if (message && typeof message === 'object' && message.poll) {
+            pollData = message.poll;
+        } else if (options && options.poll) {
+            pollData = options.poll;
+        }
+
+        if (pollData) {
+            messageContent = {
+                poll: {
+                    name: pollData.name,
+                    values: pollData.values || pollData.options || [],
+                    selectableCount: pollData.selectableCount !== undefined ? pollData.selectableCount : (pollData.selectableOptionsCount !== undefined ? pollData.selectableOptionsCount : 1),
+                    toAnnouncementGroup: pollData.toAnnouncementGroup || false
+                }
+            };
+        } else if (typeof message === 'string') {
             messageContent = { text: message };
         } else if (message && typeof message === 'object') {
-            // Handle different message types
-            switch (message.type) {
-                case 'text':
-                    messageContent = { text: message.text };
-                    if (message.mentions) {
-                        messageContent.mentions = message.mentions;
-                    }
-                    break;
-
-                case 'location':
-                    messageContent = {
-                        location: {
-                            degreesLatitude: message.latitude,
-                            degreesLongitude: message.longitude,
-                            name: message.name,
-                            address: message.address
-                        }
-                    };
-                    break;
+            if (message.richResponse) {
+                if (Array.isArray(message.richResponse)) {
+                    // Route array of submessages to sendRichMessage instead
+                    return await this.sendRichMessage(chatId, message.richResponse, options.quoted || null, { ...options, useMarkdown: true });
+                }
+                messageContent = { richResponse: message.richResponse };
+            } else {
+                // Handle different message types
+                switch (message.type) {
+                    case 'text':
+                        messageContent = { text: message.text };
+                        const { mentions: textMentions, mentionAll: textMentionAll } = this._handleMentions(message.mentions, message.mentionAll);
+                        if (textMentions) messageContent.mentions = textMentions;
+                        if (textMentionAll !== undefined) messageContent.mentionAll = textMentionAll;
+                        break;
+
+                    case 'location':
+                        messageContent = {
+                            location: {
+                                degreesLatitude: message.latitude,
+                                degreesLongitude: message.longitude,
+                                name: message.name,
+                                address: message.address
+                            }
+                        };
+                        break;
 
-                case 'contact':
-                    messageContent = {
-                        contacts: {
-                            displayName: message.fullName,
-                            contacts: [{
+                    case 'contact':
+                        messageContent = {
+                            contacts: {
                                 displayName: message.fullName,
-                                vcard: `BEGIN:VCARD\nVERSION:3.0\n` +
-                                    `FN:${message.fullName}\n` +
-                                    (message.organization ? `ORG:${message.organization};\n` : '') +
-                                    (message.phoneNumber ? `TEL;type=CELL;type=VOICE;waid=${message.phoneNumber}:+${message.phoneNumber}\n` : '') +
-                                    'END:VCARD'
-                            }]
-                        }
-                    };
-                    break;
-
-                case 'reaction':
-                    messageContent = {
-                        react: {
-                            text: message.emoji,
-                            key: message.messageKey || message.message?.key || message.key
-                        }
-                    };
-                    break;
+                                contacts: [{
+                                    displayName: message.fullName,
+                                    vcard: `BEGIN:VCARD\nVERSION:3.0\n` +
+                                        `FN:${message.fullName}\n` +
+                                        (message.organization ? `ORG:${message.organization};\n` : '') +
+                                        (message.phoneNumber ? `TEL;type=CELL;type=VOICE;waid=${message.phoneNumber}:+${message.phoneNumber}\n` : '') +
+                                        'END:VCARD'
+                                }]
+                            }
+                        };
+                        break;
+
+                    case 'reaction':
+                        messageContent = {
+                            react: {
+                                text: message.emoji,
+                                key: message.messageKey || message.message?.key || message.key
+                            }
+                        };
+                        break;
 
-                default:
-                    throw new Error('Invalid message type');
+                    default:
+                        throw new Error('Invalid message type');
+                }
             }
         } else {
             throw new Error('Invalid message content');
         }
 
         try {
-            return await this.sock.sendMessage(chatId, messageContent, { ...options, ai: true });
+            return await this.sock.sendMessage(chatId, messageContent, { ai: this.ai, ...options });
         } catch (error) {
             console.error('Error sending message:', error);
             throw error;
         }
     }
+
     /**
      * Send a media file to a chat
      * @param {string} chatId - The ID of the chat to send the media to
@@ -689,17 +859,45 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or file not found
      */
     async sendMedia(chatId, filePath, options = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
 
         try {
-            // Check if file exists
-            if (!fs.existsSync(filePath)) {
-                throw new Error('File not found: ' + filePath);
+            let fileBuffer;
+            let fileExtension;
+            let isUrl = false;
+
+            try {
+                const parsedUrl = new URL(filePath);
+                isUrl = parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:';
+            } catch (_) { }
+
+            if (isUrl) {
+                const response = await fetch(filePath);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch media from URL: ${response.statusText}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                fileBuffer = Buffer.from(arrayBuffer);
+                const contentType = response.headers.get('content-type');
+                if (contentType) {
+                    const cleanMime = contentType.split(';')[0].trim();
+                    fileExtension = '.' + mime.getExtension(cleanMime);
+                } else {
+                    const parsedUrl = new URL(filePath);
+                    fileExtension = path.extname(parsedUrl.pathname).toLowerCase();
+                }
+            } else {
+                // Check if file exists
+                if (!fs.existsSync(filePath)) {
+                    throw new Error('File not found: ' + filePath);
+                }
+                fileBuffer = fs.readFileSync(filePath);
+                fileExtension = path.extname(filePath).toLowerCase();
             }
 
-            const fileExtension = path.extname(filePath).toLowerCase();
             const caption = options.caption || '';
             let mediaMessage = {};
 
@@ -708,7 +906,7 @@ class WhatsAppClient extends EventEmitter {
                 case '.gif':
                 case '.mp4':
                     mediaMessage = {
-                        video: fs.readFileSync(filePath),
+                        video: fileBuffer,
                         caption: caption,
                         gifPlayback: options.asGif || fileExtension === '.gif',
                     }
@@ -719,9 +917,7 @@ class WhatsAppClient extends EventEmitter {
                 case '.ogg':
                 case '.wav':
                     mediaMessage = {
-                        audio: {
-                            url: filePath
-                        },
+                        audio: fileBuffer,
                         mimetype: 'audio/mp4',
                     };
                     break;
@@ -731,7 +927,7 @@ class WhatsAppClient extends EventEmitter {
                 case '.jpeg':
                 case '.png':
                     mediaMessage = {
-                        image: fs.readFileSync(filePath),
+                        image: fileBuffer,
                         caption: caption,
                     };
                     break;
@@ -740,11 +936,11 @@ class WhatsAppClient extends EventEmitter {
                     throw new Error('Unsupported file type: ' + fileExtension);
             }
 
-            if (options.mentions) {
-                mediaMessage.mentions = options.mentions;
-            }
+            const { mentions: mediaMentions, mentionAll: mediaMentionAll } = this._handleMentions(options.mentions, options.mentionAll);
+            if (mediaMentions) mediaMessage.mentions = mediaMentions;
+            if (mediaMentionAll !== undefined) mediaMessage.mentionAll = mediaMentionAll;
 
-            return await this.sock.sendMessage(chatId, mediaMessage, { ai: true });
+            return await this.sock.sendMessage(chatId, mediaMessage, { ai: this.ai });
         } catch (error) {
             console.error('Error sending media:', error);
             throw error;
@@ -760,19 +956,57 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or file not found
      */
     async sendDocument(chatId, filePath, caption = '') {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
 
         try {
-            // Check if file exists
-            if (!fs.existsSync(filePath)) {
-                throw new Error('File not found: ' + filePath);
-            }
+            let fileBuffer;
+            let fileName;
+            let mimeType;
+            let isUrl = false;
+
+            try {
+                const parsedUrl = new URL(filePath);
+                isUrl = parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:';
+            } catch (_) { }
+
+            if (isUrl) {
+                const response = await fetch(filePath);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch document from URL: ${response.statusText}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                fileBuffer = Buffer.from(arrayBuffer);
+
+                const contentType = response.headers.get('content-type');
+                if (contentType) {
+                    mimeType = contentType.split(';')[0].trim();
+                } else {
+                    mimeType = mime.getType(filePath) || 'application/octet-stream';
+                }
 
-            const fileBuffer = fs.readFileSync(filePath);
-            const fileName = path.basename(filePath);
-            const mimeType = mime.getType(filePath);
+                const contentDisposition = response.headers.get('content-disposition');
+                if (contentDisposition) {
+                    const match = contentDisposition.match(/filename="?([^"]+)"?/);
+                    if (match && match[1]) {
+                        fileName = match[1];
+                    }
+                }
+
+                if (!fileName) {
+                    const parsedUrl = new URL(filePath);
+                    fileName = path.basename(parsedUrl.pathname) || 'document';
+                }
+            } else {
+                if (!fs.existsSync(filePath)) {
+                    throw new Error('File not found: ' + filePath);
+                }
+                fileBuffer = fs.readFileSync(filePath);
+                fileName = path.basename(filePath);
+                mimeType = mime.getType(filePath) || 'application/octet-stream';
+            }
 
             const messageContent = {
                 document: fileBuffer,
@@ -783,12 +1017,15 @@ class WhatsAppClient extends EventEmitter {
 
             if (typeof caption === 'object' && caption !== null) {
                 if (caption.caption) messageContent.caption = caption.caption;
-                if (caption.mentions) messageContent.mentions = caption.mentions;
+
+                const { mentions: docMentions, mentionAll: docMentionAll } = this._handleMentions(caption.mentions, caption.mentionAll);
+                if (docMentions) messageContent.mentions = docMentions;
+                if (docMentionAll !== undefined) messageContent.mentionAll = docMentionAll;
             }
 
             return await this.sock.sendMessage(chatId, {
                 ...messageContent,
-            }, { ai: true });
+            }, { ai: this.ai });
         } catch (error) {
             console.error('Error sending document:', error);
             throw error;
@@ -811,6 +1048,7 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or message sending fails
      */
     async sendButtons(chatId, options = {}, extraOptions = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -874,7 +1112,7 @@ class WhatsAppClient extends EventEmitter {
             }
 
             // Send the message with buttons
-            return await this.sock.sendMessage(chatId, messageContent, { ...extraOptions, ai: true });
+            return await this.sock.sendMessage(chatId, messageContent, { ai: this.ai, ...extraOptions });
         } catch (error) {
             console.error('Error sending buttons:', error);
             throw error;
@@ -893,7 +1131,9 @@ class WhatsAppClient extends EventEmitter {
      * @returns {Promise<object>} The sent message info
      * @throws {Error} If client is not connected or message sending fails
      */
+
     async SendList(chatId, listOptions) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -914,7 +1154,7 @@ class WhatsAppClient extends EventEmitter {
                 })),
             };
 
-            return await this.sock.sendMessage(chatId, listMessage, { ai: true });
+            return await this.sock.sendMessage(chatId, listMessage, { ai: this.ai });
         } catch (error) {
             console.error('Error sending list message:', error);
             throw error;
@@ -929,9 +1169,10 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} options - { footer }
      */
     async sendQuickReplyV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateQuickReplyButtons(text, buttons, options);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.sendMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -940,9 +1181,10 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} options - Button options
      */
     async sendInteractiveButtonV2(jid, options) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateInteractiveButtonMessage(options);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.sendMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -953,9 +1195,10 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} options - { title, footer }
      */
     async sendUrlButtonV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateUrlButtonMessage(text, buttons, options);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.sendMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -966,9 +1209,10 @@ class WhatsAppClient extends EventEmitter {
      * @param {string} buttonText - Text on the copy button
      */
     async sendCopyCodeV2(jid, text, code, buttonText) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateCopyCodeButton(text, code, buttonText);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.sendMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -979,9 +1223,10 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} options - { title, footer }
      */
     async sendCombinedButtonsV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateCombinedButtons(text, buttons, options);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.sendMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -990,9 +1235,21 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} options - List options (title, buttonText, description, footer, sections)
      */
     async sendListV2(jid, options) {
+        jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateInteractiveListMessage(options);
-        return await this.sock.sendMessage(jid, message, { ai: true });
+        return await this.sock.relayMessage(jid, message, { ai: this.ai });
+    }
+
+    /**
+     * Send Buttons Cards Message
+     * @param {string} jid - Target JID
+     * @param {object} options - Cards options (text, title, subtile, footer, cards)
+     */
+    async sendcards(jid, options) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendMessage(jid, options, { ai: this.ai });
     }
     /**
      * Send an external ad reply with a local image
@@ -1005,6 +1262,7 @@ class WhatsAppClient extends EventEmitter {
      */
 
     async sendAdReply(number, msg, imgpath, title, body, sourceurl) {
+        number = this._normalizeJid(number);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -1030,7 +1288,7 @@ class WhatsAppClient extends EventEmitter {
                         mediaUrl: sourceurl || 'https://m.facebook.com/innovatorssoft'
                     }
                 }
-            }, { ai: true });
+            }, { ai: this.ai });
 
         } catch (err) {
             console.error('Failed to send externalAdReply:', err);
@@ -1074,7 +1332,8 @@ class WhatsAppClient extends EventEmitter {
         const results = [];
 
         try {
-            for (const participantId of participantIds) {
+            for (let participantId of participantIds) {
+                participantId = this._normalizeJid(participantId);
                 try {
                     let updateResult = await this.sock.groupParticipantsUpdate(
                         groupId,
@@ -1211,7 +1470,7 @@ class WhatsAppClient extends EventEmitter {
             // Send as text message
             return await this.sock.sendMessage(participantId, {
                 text: message
-            }, { ai: true });
+            }, { ai: this.ai });
         } catch (error) {
             console.error('Error sending group invitation:', error);
             throw error;
@@ -1678,6 +1937,8 @@ class WhatsAppClient extends EventEmitter {
      * @param {object} metadata - Sticker metadata (packName, author, etc.)
      * @returns {Promise<object>} Sent message info
      */
+
+    // send sticker
     async sendSticker(chatId, buffer, metadata = {}) {
         if (!this.isConnected) throw new Error('Client is not connected');
 
@@ -1695,7 +1956,7 @@ class WhatsAppClient extends EventEmitter {
 
             return await this.sock.sendMessage(chatId, {
                 sticker: stickerBuffer
-            }, { ai: true });
+            }, { ai: this.ai });
         } catch (error) {
             console.error('Error generating sticker:', error);
             throw error;
@@ -2370,12 +2631,34 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    /**
+     * Decrypt and aggregate poll votes
+     * @param {object} key - The message key of the poll creation message
+     * @param {Array} pollUpdates - The poll updates array from messages.update event
+     * @returns {Promise<Array>} The aggregated poll votes
+     * @throws {Error} If poll creation message is not found
+     */
+    async decryptPollVotes(key, pollUpdates) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+
+        const pollCreation = this.messageStore.getOriginalMessage(key);
+        if (!pollCreation) {
+            throw new Error('Poll creation message not found in store');
+        }
+
+        return await getAggregateVotesInPollMessage({
+            message: pollCreation.message || pollCreation,
+            pollUpdates: pollUpdates,
+        });
+    }
+
     /**
      * Update profile picture privacy setting
      * @param {string} value - 'all' | 'contacts' | 'contact_blacklist' | 'none'
      * @returns {Promise<void>}
      * @throws {Error} If client is not connected or update fails
      */
+
     async updateProfilePicturePrivacy(value) {
         if (!this.isConnected) {
             throw new Error('Client is not connected');
@@ -2520,6 +2803,255 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+
+    /**
+     * Post a status update (story) with various media types and styles
+     * @param {object} options Options for the status update
+     * @param {string} [options.text] Text content for a text status
+     * @param {string|number[]} [options.backgroundColor] Background color for text status (hex or array of rgb)
+     * @param {number} [options.font] Font type for text status (1-5)
+     * @param {string} [options.textColor] Text color (hex)
+     * @param {string} [options.imagePath] Path to image file for image status
+     * @param {string} [options.videoPath] Path to video file for video status
+     * @param {string} [options.audioPath] Path to audio file for voice note status
+     * @param {Buffer} [options.imageBuffer] Buffer containing image data
+     * @param {Buffer} [options.videoBuffer] Buffer containing video data
+     * @param {Buffer} [options.audioBuffer] Buffer containing audio data
+     * @param {string} [options.caption] Caption for image or video status
+     * @param {boolean} [options.isGif=false] Whether the video should be played as a GIF
+     * @param {Array<string>} [contacts=[]] List of JIDs who should receive the status (important for Multi-Device)
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or options are invalid
+     */
+    async sendStatus(options = {}, contacts = []) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            let statusMessage;
+
+            // Voice Note Status
+            if (options.audioPath || options.audioBuffer) {
+                const buffer = options.audioBuffer || fs.readFileSync(options.audioPath);
+                statusMessage = StatusHelper.voiceNote(buffer);
+            }
+            // Image Status
+            else if (options.imagePath || options.imageBuffer) {
+                const buffer = options.imageBuffer || fs.readFileSync(options.imagePath);
+                statusMessage = StatusHelper.image(buffer, options.caption || '');
+            }
+            // Video / GIF Status
+            else if (options.videoPath || options.videoBuffer) {
+                const buffer = options.videoBuffer || fs.readFileSync(options.videoPath);
+                if (options.isGif) {
+                    statusMessage = StatusHelper.gif(buffer, options.caption || '');
+                } else {
+                    statusMessage = StatusHelper.video(buffer, options.caption || '');
+                }
+            }
+            // Text Status
+            else if (options.text) {
+                statusMessage = StatusHelper.text(
+                    options.text,
+                    options.backgroundColor || STATUS_BACKGROUNDS.solid.purple,
+                    options.font || STATUS_FONTS.SANS_SERIF,
+                    options.textColor
+                );
+            } else {
+                throw new Error('Invalid status options: Provide text, image, video, or audio.');
+            }
+
+            // Send using the new StatusHelper
+            return await StatusHelper.send(this.sock, statusMessage, contacts);
+
+        } catch (error) {
+            console.error('Error sending status:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send a formatted table (header row + data rows)
+     * @param {string} jid 
+     * @param {string} title 
+     * @param {Array<string>} headers 
+     * @param {Array<Array<string>>} rows 
+     * @param {object} [quoted=null] 
+     * @param {object} [options={}] 
+     */
+    async sendTable(jid, title, headers, rows, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendTable(jid, title, headers, rows, quoted, { ai: this.ai, ...options });
+    }
+
+    /**
+     * Send a bulleted / single-column list (Rich AI)
+     * @param {string} jid 
+     * @param {string} title 
+     * @param {Array} items 
+     * @param {object} [quoted=null] 
+     * @param {object} [options={}] 
+     */
+    async sendRichList(jid, title, items, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendList(jid, title, items, quoted, { ai: this.ai, ...options });
+    }
+
+    /**
+     * Send a syntax-highlighted code block
+     * @param {string} jid 
+     * @param {string} code 
+     * @param {object} [quoted=null] 
+     * @param {object} [options={}] 
+     */
+    async sendCodeBlock(jid, code, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendCodeBlock(jid, code, quoted, { ai: this.ai, ...options });
+    }
+
+    /**
+     * Send LaTeX expressions as text
+     * @param {string} jid 
+     * @param {object} [quoted=null] 
+     * @param {object} [options={}] 
+     */
+    async sendLatex(jid, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        if (quoted && !quoted.key && (quoted.expressions || quoted.text || quoted.headerText || quoted.footer)) {
+            options = quoted;
+            quoted = null;
+        }
+
+        const submessages = [];
+        if (options.headerText) {
+            submessages.push({ messageType: 2, messageText: options.headerText });
+        }
+
+        const latexExpressions = (options.expressions || []).map(expr => {
+            const entry = {
+                latexExpression: expr.latexExpression,
+                url: expr.url,
+                width: expr.width,
+                height: expr.height
+            };
+            if (expr.fontHeight !== undefined) entry.fontHeight = expr.fontHeight;
+            if (expr.imageTopPadding !== undefined) entry.imageTopPadding = expr.imageTopPadding;
+            if (expr.imageLeadingPadding !== undefined) entry.imageLeadingPadding = expr.imageLeadingPadding;
+            if (expr.imageBottomPadding !== undefined) entry.imageBottomPadding = expr.imageBottomPadding;
+            if (expr.imageTrailingPadding !== undefined) entry.imageTrailingPadding = expr.imageTrailingPadding;
+            return entry;
+        });
+
+        submessages.push({ messageType: 8, latexMetadata: { text: options.text || '', expressions: latexExpressions } });
+
+        if (options.footer) {
+            submessages.push({ messageType: 2, messageText: options.footer });
+        }
+
+        return await this.sock.sendRichMessage(jid, submessages, quoted, { ai: this.ai, ...options });
+    }
+
+    /**
+     * Render a LaTeX expression to a PNG image using the online CodeCogs API, upload, and send.
+     * @param {string} jid 
+     * @param {object} [quoted=null] 
+     * @param {object|string} [options={}] LaTeX string OR options object: { formula/latex/text/expressions, caption }
+     */
+    async sendLatexImage(jid, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        if (quoted && !quoted.key && (quoted.expressions || quoted.text || quoted.headerText || quoted.footer || typeof quoted === 'string' || (Array.isArray(quoted) && quoted.length > 0))) {
+            options = quoted;
+            quoted = null;
+        }
+        const latexOptions = typeof options === 'string' ? options : { ai: this.ai, ...options };
+        return await this.sock.sendLatexImage(jid, quoted, latexOptions);
+    }
+
+    /**
+     * Render multiple LaTeX expressions as an album message.
+     * @param {string} jid 
+     * @param {object} [quoted=null] 
+     * @param {object|string} [options={}] LaTeX string OR options object: { expressions, caption }
+     */
+    async sendLatexInlineImage(jid, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        if (quoted && !quoted.key && (quoted.expressions || quoted.text || quoted.headerText || quoted.footer || typeof quoted === 'string' || (Array.isArray(quoted) && quoted.length > 0))) {
+            options = quoted;
+            quoted = null;
+        }
+        const latexOptions = typeof options === 'string' ? options : { ai: this.ai, ...options };
+        return await this.sock.sendLatexInlineImage(jid, quoted, latexOptions);
+    }
+
+    /**
+     * Send a rich markdown text message
+     * @param {string} jid 
+     * @param {string} text 
+     * @param {object} [quoted=null] 
+     */
+    async sendMarkdown(jid, text, quoted = null) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendMarkdown(jid, text, quoted);
+    }
+
+    /**
+     * Send a fully custom rich message by assembling raw submessage objects
+     * @param {string} jid 
+     * @param {Array<object>} messages 
+     * @param {object} [quoted=null] 
+     * @param {object} [options={}] 
+     */
+    async sendRichMessage(jid, messages, quoted = null, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendRichMessage(jid, messages, quoted, { ai: this.ai, ...options });
+    }
+
+    /**
+     * Capture a unified response from an incoming Meta AI message
+     * @param {object} message 
+     */
+    captureUnifiedResponse(message) {
+        if (!this.sock) throw new Error('Client is not initialized');
+        return this.sock.captureUnifiedResponse(message);
+    }
+
+    /**
+     * Send a captured unified response
+     * @param {string} jid 
+     * @param {object} [quoted=null] 
+     * @param {object} captured 
+     */
+
+    async sendUnifiedResponse(jid, quoted = null, captured) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendUnifiedResponse(jid, quoted, captured, { ai: this.ai });
+    }
+
+    async sendGroupStatus(jid, content = {}, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        if (!jid || typeof jid !== 'string' || !jid.endsWith('@g.us')) {
+            throw new Error('Invalid group JID. Expected a JID ending with @g.us');
+        }
+
+        if (!content || typeof content !== 'object') {
+            throw new Error('Invalid content. Expected an object');
+        }
+
+        return await this.sock.sendMessage(jid, { ...content, groupStatus: true }, options);
+    }
 }
 
 function formatCode(code) {
@@ -2532,4 +3064,9 @@ function formatCode(code) {
 module.exports = {
     WhatsAppClient: WhatsAppClient,
     Group: Group,
+    STATUS_BACKGROUNDS,
+    STATUS_FONTS,
+    renderLatexToPng,
+    uploadUnencryptedToWA,
+    RichSubMessageType
 }