@innovatorssoft/innovators-bot2 2.0.6 → 2.0.7

package/index.js

@@ -4,7 +4,6 @@ const {
     useMultiFileAuthState,
     DisconnectReason,
     fetchLatestBaileysVersion,
-    fetchLatestWaWebVersion,
     downloadMediaMessage,
     getCurrentSenderInfo,
     // JID Utilities
@@ -25,10 +24,13 @@ const {
     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');
@@ -38,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'))
@@ -82,6 +84,7 @@ class WhatsAppClient extends EventEmitter {
         this._storeChangeCount = 0;
         this._pairingCodeTimer = null;
         this._lastStoreSave = null;
+        this.ai = config.ai === undefined ? true : config.ai;
     }
 
     /**
@@ -165,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' })
@@ -178,7 +178,14 @@ class WhatsAppClient extends EventEmitter {
                 logger,
                 markOnlineOnConnect: false,
                 syncFullHistory: false,
-                getMessage: async (key) => (this.messageStore.getOriginalMessage(key))?.message,
+                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,
@@ -380,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') {
@@ -397,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 = '❤️') => {
@@ -416,7 +423,7 @@ class WhatsAppClient extends EventEmitter {
                                         text: emoji,
                                         key: message.key
                                     }
-                                }, { ai: true });
+                                }, { ai: this.ai });
                             }
                         });
                         return;
@@ -453,7 +460,7 @@ 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 = this._normalizeJid(info.key.remoteJid);
@@ -467,6 +474,114 @@ class WhatsAppClient extends EventEmitter {
                         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
@@ -647,69 +762,94 @@ class WhatsAppClient extends EventEmitter {
 
         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 };
-                    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;
+            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
@@ -725,12 +865,39 @@ class WhatsAppClient extends EventEmitter {
         }
 
         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 = {};
 
@@ -739,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',
                     }
@@ -750,9 +917,7 @@ class WhatsAppClient extends EventEmitter {
                 case '.ogg':
                 case '.wav':
                     mediaMessage = {
-                        audio: {
-                            url: filePath
-                        },
+                        audio: fileBuffer,
                         mimetype: 'audio/mp4',
                     };
                     break;
@@ -762,7 +927,7 @@ class WhatsAppClient extends EventEmitter {
                 case '.jpeg':
                 case '.png':
                     mediaMessage = {
-                        image: fs.readFileSync(filePath),
+                        image: fileBuffer,
                         caption: caption,
                     };
                     break;
@@ -775,7 +940,7 @@ class WhatsAppClient extends EventEmitter {
             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;
@@ -797,14 +962,51 @@ class WhatsAppClient extends EventEmitter {
         }
 
         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;
 
-            const fileBuffer = fs.readFileSync(filePath);
-            const fileName = path.basename(filePath);
-            const mimeType = mime.getType(filePath);
+            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 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,
@@ -823,7 +1025,7 @@ class WhatsAppClient extends EventEmitter {
 
             return await this.sock.sendMessage(chatId, {
                 ...messageContent,
-            }, { ai: true });
+            }, { ai: this.ai });
         } catch (error) {
             console.error('Error sending document:', error);
             throw error;
@@ -910,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;
@@ -952,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;
@@ -970,7 +1172,7 @@ class WhatsAppClient extends EventEmitter {
         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 });
     }
 
     /**
@@ -982,7 +1184,7 @@ class WhatsAppClient extends EventEmitter {
         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 });
     }
 
     /**
@@ -996,7 +1198,7 @@ class WhatsAppClient extends EventEmitter {
         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 });
     }
 
     /**
@@ -1010,7 +1212,7 @@ class WhatsAppClient extends EventEmitter {
         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 });
     }
 
     /**
@@ -1024,7 +1226,7 @@ class WhatsAppClient extends EventEmitter {
         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 });
     }
 
     /**
@@ -1036,7 +1238,7 @@ class WhatsAppClient extends EventEmitter {
         jid = this._normalizeJid(jid);
         if (!this.isConnected) throw new Error('Client is not connected');
         const message = generateInteractiveListMessage(options);
-        return await this.sock.relayMessage(jid, message, { ai: true });
+        return await this.sock.relayMessage(jid, message, { ai: this.ai });
     }
 
     /**
@@ -1047,7 +1249,7 @@ class WhatsAppClient extends EventEmitter {
     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: true });
+        return await this.sock.sendMessage(jid, options, { ai: this.ai });
     }
     /**
      * Send an external ad reply with a local image
@@ -1086,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);
@@ -1268,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;
@@ -1735,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');
 
@@ -1752,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;
@@ -2427,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');
@@ -2645,6 +2871,172 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    /**
+     * 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');
@@ -2673,5 +3065,8 @@ module.exports = {
     WhatsAppClient: WhatsAppClient,
     Group: Group,
     STATUS_BACKGROUNDS,
-    STATUS_FONTS
+    STATUS_FONTS,
+    renderLatexToPng,
+    uploadUnencryptedToWA,
+    RichSubMessageType
 }