@areumtecnologia/wasockets 2.3.0 → 2.3.1

package/README.md

@@ -224,18 +224,33 @@ client.on(Events.LABELS_UPDATE, (labels) => { /* Criação ou associação de et
 Ao escutar `Events.MESSAGE_RECEIVED`, você recebe um objeto `ctx` que já contém todos os dados mastigados e métodos de ação vinculados diretamente àquela mensagem:
 
 #### Propriedades de `ctx`:
-- `ctx.id`: ID único da mensagem.
+- `ctx.id`: ID único da mensagem (se for mensagem editada, preserva o ID original rastreável).
 - `ctx.chatId`: JID do chat (usuário, grupo ou canal).
-- `ctx.sender`: JID de quem enviou.
-- `ctx.senderNumber`: Apenas os números de telefone do remetente (sem `@s.whatsapp.net`).
-- `ctx.senderName`: Nome formatado (nome salvo, apelido comercial ou pushName).
+- `ctx.fromMe` / `ctx.isFromMe`: Booleano se a mensagem foi enviada pelo próprio bot.
+- `ctx.from`: JID de origem (remetente em recebidas, ou JID do bot em enviadas).
+- `ctx.to`: JID de destino (bot em recebidas, ou JID do chat/destinatário em enviadas).
+- `ctx.fromPushName` / `ctx.senderName`: Nome de exibição formatado ou pushName ('Você' se `fromMe`).
+- `ctx.fromNumber` / `ctx.senderNumber`: Apenas os números de telefone do remetente (sem sufixos ou `@s.whatsapp.net`).
+- `ctx.sender`: JID de quem enviou a mensagem no chat.
 - `ctx.isGroup`: Booleano indicando se é grupo (`@g.us`).
 - `ctx.isChannel`: Booleano indicando se é newsletter/canal (`@newsletter`).
-- `ctx.isFromMe`: Booleano se a mensagem foi enviada pelo próprio bot.
-- `ctx.body`: Texto principal da mensagem (já decodificado de texto, legenda, botão ou lista).
-- `ctx.type`: Tipo normalizado (`text`, `image`, `video`, `audio`, `document`, `sticker`, `poll`, etc.).
-- `ctx.media`: Instância de `MediaObject` (se houver mídia na mensagem).
-- `ctx.quoted`: Instância recursiva de `MessageContext` para a mensagem que foi citada/respondida.
+- `ctx.isBroadcast`: Booleano se é lista de transmissão ou status.
+- `ctx.body`: Texto principal da mensagem (já desempacotado recursivamente de `viewOnce`, `ephemeral`, botões, listas, etc.).
+- `ctx.type`: Tipo normalizado e amigável (28 tipos identificados: `text`, `image`, `video`, `voice`, `document`, `sticker`, `native_flow_response`, `poll_creation`, `event`, etc.).
+- `ctx.isEdited`: Booleano indicando se a mensagem é uma edição de mensagem prévia (`protocolMessage.editedMessage`).
+- `ctx.editTimestamp`: Instância de `Date` informando quando a mensagem foi editada (ou `null`).
+- `ctx.interactiveReply`: Resposta estruturada de botões, listas e fluxos nativos (`{ id, text, params, flowName, type }`).
+- `ctx.contacts`: Array com contatos e vCards parseados (`[{ name, number, org, vcard }]`), com suporte a `waid` e fallback `TEL`.
+- `ctx.location`: Coordenadas e endereço (`{ latitude, longitude, name, address, url, isLive }`).
+- `ctx.reaction`: Detalhes de reação (`{ emoji, reactedMessageId, targetKey, isRemoval, senderTimestamp }`).
+- `ctx.poll`: Dados completos de enquetes (`{ name, options, selectableOptionsCount, allowsMultipleAnswers }`).
+- `ctx.mediaDetails`: Metadados da mídia (`{ mimetype, fileName, caption, duration, isPtt, isGif, isViewOnce }`).
+- `ctx.media`: Instância de `MediaObject` para conversão rápida para buffer, base64, salvamento em disco ou Sharp.
+- `ctx.isMentioningMe`: Booleano indicando se o bot foi mencionado diretamente no texto (suporta Phone JID e LID JID).
+- `ctx.mentions` / `ctx.mentionedJids`: Array de JIDs mencionados na mensagem.
+- `ctx.isForwarded` & `ctx.forwardingScore`: Rastreamento de encaminhamento.
+- `ctx.isReply`: Booleano indicando se esta mensagem está citando outra.
+- `ctx.quoted`: Instância recursiva de `MessageContext` da mensagem citada/respondida (com controle de profundidade).
 - `ctx.raw`: O nó bruto original do WhatsApp/Baileys para casos de baixo nível.
 
 #### Ações Disponíveis em `ctx`:

package/lib/Client/Context/MessageContext.js

@@ -10,58 +10,125 @@ class MessageContext {
     /**
      * @param {import('../WaClient').WaClient} client
      * @param {Object} rawMessage - proto.IWebMessageInfo
+     * @param {number} [depth=0] - Recursion depth guard for quoted messages
      */
-    constructor(client, rawMessage) {
+    constructor(client, rawMessage, depth = 0) {
         this.client = client
-        this.raw = rawMessage
+        this.raw = rawMessage || {}
+
+        // 1. Detection of Edited Message (protocolMessage.editedMessage)
+        const editedMsg = rawMessage?.message?.protocolMessage?.editedMessage
+        this.isEdited = Boolean(editedMsg)
+
+        const effectiveKey = (this.isEdited && rawMessage.message.protocolMessage.key)
+            ? { ...rawMessage.key, ...rawMessage.message.protocolMessage.key }
+            : (rawMessage?.key || {})
+
+        const effectiveMessage = editedMsg || rawMessage?.message || null
+
+        // 2. Identity and Routing
+        this.id = effectiveKey.id || rawMessage?.key?.id || ''
+        this.chatId = effectiveKey.remoteJid || rawMessage?.key?.remoteJid || ''
+        this.fromMe = Boolean(effectiveKey.fromMe)
+        this.isFromMe = this.fromMe
 
-        const key = rawMessage.key || {}
-        this.id = key.id || ''
-        this.chatId = key.remoteJid || ''
-        this.isFromMe = Boolean(key.fromMe)
         this.isGroup = JidNormalizer.isGroup(this.chatId)
         this.isChannel = JidNormalizer.isNewsletter(this.chatId)
         this.isBroadcast = JidNormalizer.isBroadcast(this.chatId)
 
-        // Sender determination (group participant vs 1:1 chat remoteJid)
-        this.sender = this.isGroup
-            ? (key.participant || rawMessage.participant || this.chatId)
-            : this.chatId
-        this.senderNumber = JidNormalizer.toPhoneNumber(this.sender)
-        this.senderName = rawMessage.pushName || this.senderNumber || 'Desconhecido'
-
-        // Content Extraction
-        const messageContent = rawMessage.message || null
-        this.type = MessageNormalizer.extractType(messageContent)
-        this.body = MessageNormalizer.extractBody(messageContent)
-        this.mediaNode = MessageNormalizer.extractMediaNode(messageContent)
+        // Bot JID resolution
+        const sockUser = client?.sock?.user || {}
+        const clientJid = sockUser.id ? JidNormalizer.toJid(sockUser.id) : ''
+        const clientLid = sockUser.lid ? JidNormalizer.toJid(sockUser.lid) : ''
+
+        // Origin and Destination (from / to)
+        if (this.fromMe) {
+            this.from = clientJid || this.chatId
+            this.to = this.chatId
+            this.fromPushName = sockUser.name || sockUser.notify || 'Você'
+        } else {
+            this.from = this.isGroup
+                ? (effectiveKey.participant || rawMessage?.participant || this.chatId)
+                : this.chatId
+            this.to = clientJid || this.chatId
+            this.fromPushName = rawMessage?.pushName || JidNormalizer.toPhoneNumber(this.from) || 'Desconhecido'
+        }
+
+        this.sender = this.from
+        this.fromNumber = JidNormalizer.toPhoneNumber(this.from)
+        this.senderNumber = this.fromNumber
+        this.senderName = this.fromPushName
+
+        // Timestamps
+        const rawTs = Number(rawMessage?.messageTimestamp || Math.floor(Date.now() / 1000))
+        this.timestamp = new Date(rawTs > 10000000000 ? rawTs : rawTs * 1000)
+        this.editTimestamp = this.isEdited
+            ? new Date(Number(rawMessage.message.protocolMessage.timestampMs || Date.now()))
+            : null
+
+        // 3. Content Decoupling & Typed Parsers
+        this.type = MessageNormalizer.extractType(effectiveMessage)
+        this.body = MessageNormalizer.extractBody(effectiveMessage)
+        this.interactiveReply = MessageNormalizer.extractInteractiveReply(effectiveMessage)
+        this.contacts = MessageNormalizer.extractContacts(effectiveMessage)
+        this.location = MessageNormalizer.extractLocation(effectiveMessage)
+        this.reaction = MessageNormalizer.extractReaction(effectiveMessage)
+        this.poll = MessageNormalizer.extractPollCreation(effectiveMessage, rawMessage)
+
+        // 4. Media Normalization
+        this.mediaNode = MessageNormalizer.extractMediaNode(effectiveMessage)
         this.hasMedia = Boolean(this.mediaNode)
         this.media = this.hasMedia ? new MediaObject(this.mediaNode, this.type) : null
-        this.timestamp = Number(rawMessage.messageTimestamp || Math.floor(Date.now() / 1000))
-
-        // Context info & mentions
-        this.contextInfo = MessageNormalizer.extractContextInfo(messageContent)
-        this.mentionedJids = this.contextInfo?.mentionedJid || []
+        this.mediaDetails = MessageNormalizer.extractMediaDetails(effectiveMessage)
+
+        // 5. Context Info, Mentions & Forwarding
+        this.contextInfo = MessageNormalizer.extractContextInfo(effectiveMessage)
+        this.mentions = this.contextInfo?.mentionedJid || []
+        this.mentionedJids = this.mentions
+        this.isForwarded = Boolean(this.contextInfo?.isForwarded)
+        this.forwardingScore = Number(this.contextInfo?.forwardingScore || 0)
+
+        // Checks if the bot was directly mentioned (by PN or LID)
+        this.isMentioningMe = Boolean(
+            (clientJid && this.mentions.includes(clientJid)) ||
+            (clientLid && this.mentions.includes(clientLid))
+        )
 
-        // Quoted message parsing
+        // 6. Quoted Message Parsing (Recursion with depth limit 1)
+        this.isReply = Boolean(this.contextInfo?.quotedMessage)
         this.quoted = null
-        if (this.contextInfo?.quotedMessage) {
-            const quotedMsg = this.contextInfo.quotedMessage
-            this.quoted = {
-                id: this.contextInfo.stanzaId,
-                sender: this.contextInfo.participant,
-                senderNumber: JidNormalizer.toPhoneNumber(this.contextInfo.participant),
-                type: MessageNormalizer.extractType(quotedMsg),
-                body: MessageNormalizer.extractBody(quotedMsg),
-                raw: quotedMsg
+
+        if (this.isReply && this.contextInfo?.quotedMessage && depth === 0) {
+            const quotedParticipant = this.contextInfo.participant || this.chatId
+            const quotedRaw = {
+                key: {
+                    remoteJid: this.chatId,
+                    id: this.contextInfo.stanzaId,
+                    fromMe: clientJid && JidNormalizer.toJid(quotedParticipant) === clientJid,
+                    participant: quotedParticipant
+                },
+                message: this.contextInfo.quotedMessage,
+                pushName: this.contextInfo.pushName
+            }
+            try {
+                this.quoted = new MessageContext(this.client, quotedRaw, depth + 1)
+            } catch {
+                this.quoted = {
+                    id: this.contextInfo.stanzaId,
+                    sender: quotedParticipant,
+                    senderNumber: JidNormalizer.toPhoneNumber(quotedParticipant),
+                    type: MessageNormalizer.extractType(this.contextInfo.quotedMessage),
+                    body: MessageNormalizer.extractBody(this.contextInfo.quotedMessage),
+                    raw: this.contextInfo.quotedMessage
+                }
             }
         }
     }
 
     /**
      * Responde citando esta mensagem automaticamente
-     * @param {string|Object} content - Texto ou objeto de mensagem do WaSockets
-     * @param {Object} [options={}] - Opções adicionais de envio
+     * @param {string|Object} content - Texto ou payload de mensagem
+     * @param {Object} [options={}]
      */
     async reply(content, options = {}) {
         const payload = typeof content === 'string' ? { text: content } : content
@@ -72,8 +139,8 @@ class MessageContext {
     }
 
     /**
-     * Reage à mensagem com um emoji
-     * @param {string} emoji - Emoji único (ex: '👍', '❤️', '🔥')
+     * Reage à mensagem com um emoji (ou string vazia para remover)
+     * @param {string} emoji
      */
     async react(emoji) {
         return this.client.sendMessage(this.chatId, {
@@ -104,13 +171,13 @@ class MessageContext {
      * Marca esta mensagem como lida (ticks azuis)
      */
     async markRead() {
-        if (!this.client.sock?.readMessages) return
+        if (!this.client?.sock?.readMessages) return
         return this.client.sock.readMessages([this.raw.key])
     }
 
     /**
      * Encaminha esta mensagem para outro destinatário
-     * @param {string} targetJid - Destinatário
+     * @param {string} targetJid
      * @param {Object} [options={}]
      */
     async forward(targetJid, options = {}) {
@@ -122,10 +189,10 @@ class MessageContext {
 
     /**
      * Fixa a mensagem no chat com duração configurável
-     * @param {number} [durationInSeconds=86400] - 86400 (24h), 604800 (7d), 2592000 (30d)
+     * @param {number} [durationInSeconds=86400]
      */
     async pin(durationInSeconds = 86400) {
-        if (!this.client.sock?.pinInChatMessage) {
+        if (!this.client?.sock?.pinInChatMessage) {
             throw new Error('Método pinInChatMessage indisponível no socket.')
         }
         return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 1, durationInSeconds)
@@ -135,7 +202,7 @@ class MessageContext {
      * Desafixa a mensagem do topo da conversa
      */
     async unpin() {
-        if (!this.client.sock?.pinInChatMessage) {
+        if (!this.client?.sock?.pinInChatMessage) {
             throw new Error('Método pinInChatMessage indisponível no socket.')
         }
         return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 2)

package/lib/Client/Normalizers/EventNormalizer.js

@@ -20,9 +20,17 @@ class EventNormalizer {
             if (!Array.isArray(messages)) return
 
             for (const rawMsg of messages) {
-                // Ignore stub or protocol messages if empty
+                // Ignore stub or protocol messages if completely empty
                 if (!rawMsg.message && !rawMsg.messageStubType) continue
 
+                // Handle protocol revoke messages explicitly
+                const isRevoke = rawMsg.message?.protocolMessage?.type === 0
+                if (isRevoke) {
+                    client.emit(Events.MESSAGE_DELETE, {
+                        keys: [rawMsg.message.protocolMessage.key || rawMsg.key]
+                    })
+                }
+
                 const ctx = new MessageContext(client, rawMsg)
 
                 if (ctx.isFromMe) {
@@ -30,6 +38,15 @@ class EventNormalizer {
                 } else {
                     client.emit(Events.MESSAGE_RECEIVED, ctx, rawMsg)
                 }
+
+                // If message is an edit, also notify on MESSAGE_UPDATE
+                if (ctx.isEdited) {
+                    client.emit(Events.MESSAGE_UPDATE, [{
+                        key: ctx.raw.key,
+                        update: { message: ctx.raw.message },
+                        ctx
+                    }])
+                }
             }
         })
 

package/lib/Client/Normalizers/JidNormalizer.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true })
 
 class JidNormalizer {
     /**
-     * Sanitizes and normalizes any phone number or JID string into a canonical JID
+     * Sanitizes and normalizes any phone number or JID string into a canonical JID,
+     * stripping device specifiers (e.g., ":1@s.whatsapp.net" -> "@s.whatsapp.net")
      * @param {string} input - Phone number (e.g., "+55 (11) 99999-9999") or existing JID
      * @returns {string} Normalized JID (e.g., "5511999999999@s.whatsapp.net")
      */
@@ -13,7 +14,9 @@ class JidNormalizer {
         const cleaned = input.trim()
 
         if (cleaned.includes('@')) {
-            return cleaned
+            const [userPart, server] = cleaned.split('@')
+            const cleanUser = userPart.split(':')[0]
+            return `${cleanUser}@${server}`
         }
 
         const digits = cleaned.replace(/\D/g, '')

package/lib/Client/Normalizers/MessageNormalizer.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true })
 
 class MessageNormalizer {
     /**
-     * Unwraps container wrappers (ephemeral, viewOnce, documentWithCaption, etc.)
+     * Recursively unwraps all container wrappers (ephemeral, viewOnce, associatedChild, etc.)
      * @param {Object} rawMessageContent - raw message node from proto
      * @returns {Object} Unwrapped message object
      */
@@ -12,81 +12,347 @@ class MessageNormalizer {
         if (!rawMessageContent) return null
 
         let msg = rawMessageContent
-        while (
-            msg.ephemeralMessage ||
-            msg.viewOnceMessage ||
-            msg.viewOnceMessageV2 ||
-            msg.viewOnceMessageV2Extension ||
-            msg.documentWithCaptionMessage
-        ) {
-            msg =
-                msg.ephemeralMessage?.message ||
-                msg.viewOnceMessage?.message ||
-                msg.viewOnceMessageV2?.message ||
-                msg.viewOnceMessageV2Extension?.message ||
-                msg.documentWithCaptionMessage?.message ||
-                msg
+        let unwrapped = true
+
+        // Loop to peel away multiple layers of wrappers if nested
+        while (unwrapped && msg) {
+            unwrapped = false
+
+            if (msg.ephemeralMessage?.message) {
+                msg = msg.ephemeralMessage.message
+                unwrapped = true
+                continue
+            }
+            if (msg.viewOnceMessage?.message) {
+                msg = msg.viewOnceMessage.message
+                unwrapped = true
+                continue
+            }
+            if (msg.viewOnceMessageV2?.message) {
+                msg = msg.viewOnceMessageV2.message
+                unwrapped = true
+                continue
+            }
+            if (msg.viewOnceMessageV2Extension?.message) {
+                msg = msg.viewOnceMessageV2Extension.message
+                unwrapped = true
+                continue
+            }
+            if (msg.documentWithCaptionMessage?.message) {
+                msg = msg.documentWithCaptionMessage.message
+                unwrapped = true
+                continue
+            }
+            if (msg.associatedChildMessage?.message) {
+                msg = msg.associatedChildMessage.message
+                unwrapped = true
+                continue
+            }
         }
 
         return msg
     }
 
     /**
-     * Identifies the primary content type of the message
-     * @param {Object} messageContent - Unwrapped message content
-     * @returns {string} Normalized type (e.g., 'text', 'image', 'video', 'audio', etc.)
+     * Identifies the primary friendly content type of the message (28 distinct types)
+     * @param {Object} messageContent - Raw or unwrapped message content
+     * @returns {string} Normalized friendly type
      */
     static extractType(messageContent) {
         const msg = this.unwrapMessage(messageContent)
         if (!msg) return 'unknown'
 
+        // 1. Text & Media Basics
         if (msg.conversation || msg.extendedTextMessage) return 'text'
         if (msg.imageMessage) return 'image'
+        if (msg.albumMessage) return 'album'
         if (msg.videoMessage) return msg.videoMessage.gifPlayback ? 'gif' : 'video'
         if (msg.audioMessage) return msg.audioMessage.ptt ? 'voice' : 'audio'
         if (msg.documentMessage) return 'document'
         if (msg.stickerMessage) return 'sticker'
+        if (msg.locationMessage) return 'location'
+        if (msg.liveLocationMessage) return 'live_location'
         if (msg.contactMessage || msg.contactsArrayMessage) return 'contact'
-        if (msg.locationMessage || msg.liveLocationMessage) return 'location'
-        if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) return 'poll'
+
+        // 2. Polls & Events
+        if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) return 'poll_creation'
+        if (msg.pollUpdateMessage) return 'poll_update'
+        if (msg.eventMessage) return 'event'
+        if (msg.eventResponseMessage || msg.encEventResponseMessage) return 'event_response'
+
+        // 3. Reactions & Pins
         if (msg.reactionMessage) return 'reaction'
-        if (msg.interactiveMessage || msg.interactiveResponseMessage) return 'interactive'
-        if (msg.buttonsResponseMessage || msg.templateButtonReplyMessage) return 'button_reply'
+        if (msg.pinInChatMessage) return 'pin_in_chat'
+        if (msg.unpinInChatMessage) return 'unpin_in_chat'
+
+        // 4. Replies from Buttons, Lists & Questions
+        if (msg.buttonsResponseMessage) return 'button_reply'
         if (msg.listResponseMessage) return 'list_reply'
+        if (msg.templateButtonReplyMessage) return 'template_button_reply'
+        if (msg.questionReplyMessage) return 'question_reply'
+
+        // 5. Specific Interactive Flow Buttons
+        const firstBtnName = msg.interactiveMessage?.interactiveButtons?.[0]?.name
+        if (firstBtnName) {
+            switch (firstBtnName) {
+                case 'review_and_pay': return 'review_and_pay'
+                case 'review_order': return 'review_order'
+                case 'quick_reply': return 'quick_reply'
+                case 'cta_url': return 'cta_url'
+                case 'cta_copy': return 'cta_copy'
+                case 'cta_call': return 'cta_call'
+                case 'voice_call': return 'voice_call'
+                case 'payment_info': return 'payment_info'
+            }
+        }
+
+        // 6. Native Flow Responses
+        if (msg.interactiveResponseMessage?.nativeFlowResponseMessage) {
+            const flowName = msg.interactiveResponseMessage.nativeFlowResponseMessage.name
+            if (flowName === 'menu_options') return 'native_flow_menu_options_response'
+            return 'native_flow_response'
+        }
+
+        // 7. Interactive Containers
+        if (msg.interactiveMessage?.interactiveButtons) return 'interactive_buttons'
+        if (msg.interactiveMessage?.interactiveList) return 'interactive_list'
+        if (msg.interactiveResponseMessage) return 'interactive_response'
+        if (msg.interactiveMessage) return 'interactive_message'
+
+        // 8. Protocol
         if (msg.protocolMessage) return 'protocol'
 
+        // Fallback to first non-metadata proto key
         const keys = Object.keys(msg).filter(k => k !== 'messageContextInfo' && k !== 'senderKeyDistributionMessage')
         return keys[0] ? keys[0].replace('Message', '').toLowerCase() : 'unknown'
     }
 
     /**
      * Extracts readable text content across diverse message structures
-     * @param {Object} messageContent - Unwrapped message content
+     * @param {Object} messageContent - Raw or unwrapped message content
      * @returns {string} Text body
      */
     static extractBody(messageContent) {
         const msg = this.unwrapMessage(messageContent)
         if (!msg) return ''
 
+        // Direct Text
         if (msg.conversation) return msg.conversation
         if (msg.extendedTextMessage?.text) return msg.extendedTextMessage.text
+
+        // Media Captions
         if (msg.imageMessage?.caption) return msg.imageMessage.caption
         if (msg.videoMessage?.caption) return msg.videoMessage.caption
         if (msg.documentMessage?.caption) return msg.documentMessage.caption
+
+        // Button / List selections
         if (msg.buttonsResponseMessage?.selectedDisplayText) return msg.buttonsResponseMessage.selectedDisplayText
+        if (msg.buttonsResponseMessage?.selectedButtonId) return msg.buttonsResponseMessage.selectedButtonId
         if (msg.listResponseMessage?.title) return msg.listResponseMessage.title
+        if (msg.templateButtonReplyMessage?.selectedDisplayText) return msg.templateButtonReplyMessage.selectedDisplayText
         if (msg.templateButtonReplyMessage?.selectedId) return msg.templateButtonReplyMessage.selectedId
+
+        // Interactive / Native Flows
+        if (msg.interactiveResponseMessage?.body?.text) return msg.interactiveResponseMessage.body.text
         if (msg.interactiveResponseMessage?.nativeFlowResponseMessage?.paramsJson) {
             return msg.interactiveResponseMessage.nativeFlowResponseMessage.paramsJson
         }
+        if (msg.interactiveMessage?.body?.text) return msg.interactiveMessage.body.text
+
+        // Polls, Reactions, Questions & Locations
         if (msg.pollCreationMessage?.name) return msg.pollCreationMessage.name
         if (msg.pollCreationMessageV2?.name) return msg.pollCreationMessageV2.name
         if (msg.pollCreationMessageV3?.name) return msg.pollCreationMessageV3.name
         if (msg.reactionMessage?.text) return msg.reactionMessage.text
+        if (msg.questionReplyMessage?.message?.extendedTextMessage?.text) return msg.questionReplyMessage.message.extendedTextMessage.text
+        if (msg.questionReplyMessage?.answer) return msg.questionReplyMessage.answer
+        if (msg.locationMessage?.name || msg.locationMessage?.address) {
+            return [msg.locationMessage.name, msg.locationMessage.address].filter(Boolean).join(' - ')
+        }
 
         return ''
     }
 
+    /**
+     * Extracts and safely parses interactive button/list responses
+     * @param {Object} messageContent - Unwrapped message content
+     * @returns {Object|null} { id, text, params, flowName, type }
+     */
+    static extractInteractiveReply(messageContent) {
+        const msg = this.unwrapMessage(messageContent)
+        if (!msg) return null
+
+        // 1. Classic Button Response
+        if (msg.buttonsResponseMessage) {
+            return {
+                id: msg.buttonsResponseMessage.selectedButtonId || '',
+                text: msg.buttonsResponseMessage.selectedDisplayText || '',
+                type: 'button'
+            }
+        }
+
+        // 2. List Dropdown Selection
+        if (msg.listResponseMessage) {
+            const row = msg.listResponseMessage.singleSelectReply
+            return {
+                id: row?.selectedRowId || '',
+                text: msg.listResponseMessage.title || '',
+                description: row?.description || '',
+                type: 'list'
+            }
+        }
+
+        // 3. Native Flow Interactive Response
+        if (msg.interactiveResponseMessage?.nativeFlowResponseMessage) {
+            const flow = msg.interactiveResponseMessage.nativeFlowResponseMessage
+            let params = {}
+            if (flow.paramsJson) {
+                try {
+                    params = JSON.parse(flow.paramsJson)
+                } catch {
+                    params = { raw: flow.paramsJson }
+                }
+            }
+
+            const id = params?.id || params?.selected_id || params?.row_id || flow.name || ''
+            return {
+                id,
+                text: flow.paramsJson || '',
+                params,
+                flowName: flow.name || '',
+                type: 'native_flow'
+            }
+        }
+
+        // 4. Template Button Reply
+        if (msg.templateButtonReplyMessage) {
+            return {
+                id: msg.templateButtonReplyMessage.selectedId || '',
+                text: msg.templateButtonReplyMessage.selectedDisplayText || '',
+                type: 'template_button'
+            }
+        }
+
+        // 5. Question Reply (Channels)
+        if (msg.questionReplyMessage) {
+            return {
+                id: msg.questionReplyMessage.selectedButtonId || '',
+                text: msg.questionReplyMessage.selectedDisplayText || msg.questionReplyMessage.answer || '',
+                type: 'question_reply'
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * Extracts and parses contacts from vCards
+     * @param {Object} messageContent - Unwrapped message content
+     * @returns {Array<{ name: string, number: string, org?: string, vcard: string }>}
+     */
+    static extractContacts(messageContent) {
+        const msg = this.unwrapMessage(messageContent)
+        if (!msg) return []
+
+        const parseVcard = (vcard = '') => {
+            const nameMatch = vcard.match(/FN:(.+)/i)
+            // Tenta waid= primeiro, se não encontrar pega TEL
+            const waidMatch = vcard.match(/waid=(\d+)/i)
+            const telMatch = vcard.match(/TEL[^:]*:([+\d\s().-]+)/i)
+            const orgMatch = vcard.match(/ORG:([^;\n\r]+)/i)
+
+            let number = ''
+            if (waidMatch) {
+                number = waidMatch[1].replace(/\D/g, '')
+            } else if (telMatch) {
+                number = telMatch[1].replace(/\D/g, '')
+            }
+
+            return {
+                name: (nameMatch ? nameMatch[1] : '').replace(/\\/g, '').trim(),
+                number,
+                org: orgMatch ? orgMatch[1].trim() : undefined,
+                vcard
+            }
+        }
+
+        if (msg.contactMessage) {
+            return [parseVcard(msg.contactMessage.vcard)]
+        }
+
+        if (msg.contactsArrayMessage?.contacts) {
+            return msg.contactsArrayMessage.contacts.map(c => parseVcard(c.vcard))
+        }
+
+        return []
+    }
+
+    /**
+     * Extracts coordinates and metadata from location messages
+     * @param {Object} messageContent - Unwrapped message content
+     * @returns {Object|null}
+     */
+    static extractLocation(messageContent) {
+        const msg = this.unwrapMessage(messageContent)
+        if (!msg) return null
+
+        const loc = msg.locationMessage || msg.liveLocationMessage
+        if (!loc) return null
+
+        return {
+            latitude: Number(loc.degreesLatitude || 0),
+            longitude: Number(loc.degreesLongitude || 0),
+            name: loc.name || '',
+            address: loc.address || '',
+            url: loc.url || '',
+            accuracyInMeters: loc.accuracyInMeters ? Number(loc.accuracyInMeters) : undefined,
+            speedInMps: loc.speedInMps ? Number(loc.speedInMps) : undefined,
+            isLive: Boolean(msg.liveLocationMessage)
+        }
+    }
+
+    /**
+     * Extracts reaction details
+     * @param {Object} messageContent - Unwrapped message content
+     * @returns {Object|null}
+     */
+    static extractReaction(messageContent) {
+        const msg = this.unwrapMessage(messageContent)
+        if (!msg?.reactionMessage) return null
+
+        const reaction = msg.reactionMessage
+        return {
+            emoji: reaction.text || '',
+            reactedMessageId: reaction.key?.id || '',
+            targetKey: reaction.key || null,
+            isRemoval: !reaction.text,
+            senderTimestamp: reaction.senderTimestampMs ? new Date(Number(reaction.senderTimestampMs)) : new Date()
+        }
+    }
+
+    /**
+     * Extracts poll creation structure
+     * @param {Object} messageContent - Unwrapped message content
+     * @param {Object} [rawMessage]
+     * @returns {Object|null}
+     */
+    static extractPollCreation(messageContent, rawMessage) {
+        const msg = this.unwrapMessage(messageContent)
+        const poll = msg?.pollCreationMessage || msg?.pollCreationMessageV2 || msg?.pollCreationMessageV3
+        if (!poll) return null
+
+        return {
+            id: rawMessage?.key?.id || '',
+            name: poll.name || '',
+            selectableOptionsCount: Number(poll.selectableOptionsCount || 1),
+            allowsMultipleAnswers: Number(poll.selectableOptionsCount || 1) > 1,
+            options: (poll.options || []).map(opt => ({
+                name: opt.optionName || '',
+                hash: opt.optionHash ? Buffer.from(opt.optionHash).toString('hex') : null
+            }))
+        }
+    }
+
     /**
      * Extracts media node if present
      * @param {Object} messageContent - Unwrapped message content
@@ -106,6 +372,26 @@ class MessageNormalizer {
         )
     }
 
+    /**
+     * Extracts structured media details
+     * @param {Object} messageContent - Unwrapped message content
+     * @returns {Object|null}
+     */
+    static extractMediaDetails(messageContent) {
+        const node = this.extractMediaNode(messageContent)
+        if (!node) return null
+
+        return {
+            mimetype: node.mimetype || '',
+            fileName: node.fileName || '',
+            caption: node.caption || '',
+            duration: node.seconds ? Number(node.seconds) : null,
+            isPtt: Boolean(node.ptt),
+            isGif: Boolean(node.gifPlayback),
+            isViewOnce: Boolean(node.viewOnce)
+        }
+    }
+
     /**
      * Extracts quoted message context info
      * @param {Object} messageContent - Unwrapped message content
@@ -125,6 +411,8 @@ class MessageNormalizer {
             msg.buttonsResponseMessage?.contextInfo ||
             msg.listResponseMessage?.contextInfo ||
             msg.interactiveResponseMessage?.contextInfo ||
+            msg.templateButtonReplyMessage?.contextInfo ||
+            msg.messageContextInfo ||
             null
         )
     }

package/lib/Client/index.d.ts

@@ -92,13 +92,66 @@ export declare class CallContext {
     playAudio(audioPathOrBuffer: string | Buffer): Promise<any>
 }
 
+export interface InteractiveReplyData {
+    id: string
+    text: string
+    params?: any
+    flowName?: string
+    description?: string
+    type: 'button' | 'list' | 'native_flow' | 'template_button' | 'question_reply' | string
+}
+
+export interface ContactData {
+    name: string
+    number: string
+    org?: string
+    vcard: string
+}
+
+export interface LocationData {
+    latitude: number
+    longitude: number
+    name: string
+    address: string
+    url: string
+    accuracyInMeters?: number
+    speedInMps?: number
+    isLive: boolean
+}
+
+export interface ReactionData {
+    emoji: string
+    reactedMessageId: string
+    targetKey: any
+    isRemoval: boolean
+    senderTimestamp: Date
+}
+
+export interface PollData {
+    id: string
+    name: string
+    selectableOptionsCount: number
+    allowsMultipleAnswers: boolean
+    options: Array<{ name: string; hash: string | null }>
+}
+
+export interface MediaDetailsData {
+    mimetype: string
+    fileName: string
+    caption: string
+    duration: number | null
+    isPtt: boolean
+    isGif: boolean
+    isViewOnce: boolean
+}
+
 export interface QuotedMessageContext {
     id: string
     sender: string
     senderNumber: string
     type: string
     body: string
-    raw: proto.IMessage
+    raw: proto.IMessage | any
 }
 
 export declare class MessageContext {
@@ -106,24 +159,48 @@ export declare class MessageContext {
     raw: proto.IWebMessageInfo
     id: string
     chatId: string
+    fromMe: boolean
     isFromMe: boolean
     isGroup: boolean
     isChannel: boolean
     isBroadcast: boolean
+
+    from: string
+    to: string
+    fromPushName: string
+    fromNumber: string
     sender: string
     senderNumber: string
     senderName: string
+
+    timestamp: Date
+    isEdited: boolean
+    editTimestamp: Date | null
+
     type: string
     body: string
+    interactiveReply: InteractiveReplyData | null
+    contacts: ContactData[]
+    location: LocationData | null
+    reaction: ReactionData | null
+    poll: PollData | null
+
     mediaNode: any | null
     hasMedia: boolean
     media: MediaObject | null
-    timestamp: number
+    mediaDetails: MediaDetailsData | null
+
     contextInfo: proto.IContextInfo | null
+    mentions: string[]
     mentionedJids: string[]
-    quoted: QuotedMessageContext | null
+    isForwarded: boolean
+    forwardingScore: number
+    isMentioningMe: boolean
+
+    isReply: boolean
+    quoted: MessageContext | QuotedMessageContext | null
 
-    constructor(client: WaClient, rawMessage: proto.IWebMessageInfo)
+    constructor(client: WaClient, rawMessage: proto.IWebMessageInfo, depth?: number)
 
     reply(content: string | AnyMessageContent, options?: MiscMessageGenerationOptions): Promise<proto.WebMessageInfo | undefined>
     react(emoji: string): Promise<proto.WebMessageInfo | undefined>
@@ -397,7 +474,13 @@ export declare class MessageNormalizer {
     static unwrapMessage(rawMessageContent: any): any
     static extractType(messageContent: any): string
     static extractBody(messageContent: any): string
+    static extractInteractiveReply(messageContent: any): InteractiveReplyData | null
+    static extractContacts(messageContent: any): ContactData[]
+    static extractLocation(messageContent: any): LocationData | null
+    static extractReaction(messageContent: any): ReactionData | null
+    static extractPollCreation(messageContent: any, rawMessage?: any): PollData | null
     static extractMediaNode(messageContent: any): any | null
+    static extractMediaDetails(messageContent: any): MediaDetailsData | null
     static extractContextInfo(messageContent: any): proto.IContextInfo | null
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@areumtecnologia/wasockets",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "whatsappVersion": "2.3000.1053049953",
   "description": "Communication Library By areumtecnologia",
   "keywords": [],