@badzz88/baileys 8.5.2 → 8.5.4

package/lib/Socket/messages-send.js

@@ -48,26 +48,47 @@ const makeMessagesSocket = config => {
 		trustInteropContact
 	} = sock
 	const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
-	/**
-	 * Set of tctoken storage JIDs with a fire-and-forget issuePrivacyTokens IQ in flight.
-	 * Prevents duplicate IQs from rapid back-to-back sends before senderTimestamp persists.
-	 */
+	
+	
+	const resolveStatusAudience = async (groupJids, includeMe = false) => {
+		const myJid = authState.creds.me?.id
+		const seen = new Set()
+		const allUsers = []
+		for (const gjid of groupJids) {
+			let meta
+			try {
+				meta = cachedGroupMetadata ? await cachedGroupMetadata(gjid) : null
+				if (!meta) meta = await groupMetadata(gjid)
+			} catch {
+				continue
+			}
+			for (const p of meta?.participants || []) {
+				const id = p.id
+				if (!id || seen.has(id)) continue
+				if (!includeMe && id === myJid) continue
+				seen.add(id)
+				allUsers.push(id)
+			}
+		}
+		return { allUsers }
+	}
+	
 	const inFlightTcTokenIssuance = new Set()
 	const userDevicesCache =
 		config.userDevicesCache ||
 		new node_cache_1.default({
-			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, 
 			useClones: false
 		})
 	const peerSessionsCache = new node_cache_1.default({
 		stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES,
 		useClones: false
 	})
-	// Initialize message retry manager if enabled
+	
 	const messageRetryManager = enableRecentMessageCache
 		? new Utils_1.MessageRetryManager(logger, maxMsgRetryCount)
 		: null
-	// Prevent race conditions in Signal session encryption by user
+	
 	const encryptionMutex = (0, make_mutex_1.makeKeyedMutex)()
 	let mediaConn
 	const refreshMediaConn = async (forceGet = false) => {
@@ -84,7 +105,7 @@ const makeMessagesSocket = config => {
 					content: [{ tag: 'media_conn', attrs: {} }]
 				})
 				const mediaConnNode = (0, WABinary_1.getBinaryNodeChild)(result, 'media_conn')
-				// TODO: explore full length of data that whatsapp provides
+				
 				const node = {
 					hosts: (0, WABinary_1.getBinaryNodeChildren)(mediaConnNode, 'host').map(({ attrs }) => ({
 						hostname: attrs.hostname,
@@ -100,10 +121,7 @@ const makeMessagesSocket = config => {
 		}
 		return mediaConn
 	}
-	/**
-	 * generic send receipt function
-	 * used for receipts of phone call, read, delivery etc.
-	 * */
+	
 	const sendReceipt = async (jid, participant, messageIds, type, sts) => {
 		if (!messageIds || messageIds.length === 0) {
 			throw new boom_1.Boom('missing ids in receipt')
@@ -123,7 +141,7 @@ const makeMessagesSocket = config => {
 			node.attrs.recipient = jid
 			node.attrs.to = participant
 		} else if (isInterop && !type) {
-			// Delivery receipt to interop contact: WA sends to device-qualified JID (user:0@interop)
+			
 			const { user } = (0, WABinary_1.jidDecode)(jid)
 			node.attrs.to = `${user}:0@interop`
 		} else {
@@ -135,7 +153,7 @@ const makeMessagesSocket = config => {
 		if (type) {
 			node.attrs.type = type
 		}
-		// Interop bridge requires sts (microsecond stanza timestamp) from the original message
+		
 		if (isInterop && sts) {
 			node.attrs.sts = sts
 		}
@@ -155,21 +173,21 @@ const makeMessagesSocket = config => {
 		logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages')
 		await sendNode(node)
 	}
-	/** Correctly bulk send receipts to multiple chats, participants */
+	
 	const sendReceipts = async (keys, type) => {
 		const recps = (0, Utils_1.aggregateMessageKeysNotFromMe)(keys)
 		for (const { jid, participant, messageIds, sts } of recps) {
 			await sendReceipt(jid, participant, messageIds, type, sts)
 		}
 	}
-	/** Bulk read messages. Keys can be from different chats & participants */
+	
 	const readMessages = async keys => {
 		const privacySettings = await fetchPrivacySettings()
-		// based on privacy settings, we have to change the read type
+		
 		const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self'
 		await sendReceipts(keys, readType)
 	}
-	/** Fetch all the devices we've to send a message to */
+	
 	const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
 		const deviceResults = []
 		if (!useCache) {
@@ -227,17 +245,26 @@ const makeMessagesSocket = config => {
 			}
 		}
 		const query = new WAUSync_1.USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol()
+		
+		
+		const pnJidsToFetch = toFetch.filter(jid => (0, WABinary_1.isPnUser)(jid) || (0, WABinary_1.isHostedPnUser)(jid))
+		const cachedLidPairs = pnJidsToFetch.length
+			? (await signalRepository.lidMapping.getLIDsForPNs(pnJidsToFetch)) || []
+			: []
+		const cachedLidByPn = new Map(cachedLidPairs.map(({ pn, lid }) => [pn, lid]))
 		for (const jid of toFetch) {
-			query.withUser(new WAUSync_1.USyncUser().withId(jid)) // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
+			const syncUser = new WAUSync_1.USyncUser().withId(jid)
+			const cachedLid = cachedLidByPn.get(jid)
+			if (cachedLid) syncUser.withLid(cachedLid)
+			query.withUser(syncUser)
 		}
 		const result = await sock.executeUSyncQuery(query)
 		if (result) {
-			// TODO: LID MAP this stuff (lid protocol will now return lid with devices)
 			const lidResults = result.list.filter(a => !!a.lid)
 			if (lidResults.length > 0) {
 				logger.trace('Storing LID maps from device call')
 				await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })))
-				// Force-refresh sessions for newly mapped LIDs to align identity addressing
+				
 				try {
 					const lids = lidResults.map(a => a.lid)
 					if (lids.length) {
@@ -258,10 +285,10 @@ const makeMessagesSocket = config => {
 				deviceMap[item.user] = deviceMap[item.user] || []
 				deviceMap[item.user]?.push(item)
 			}
-			// Process each user's devices as a group for bulk LID migration
+			
 			for (const [user, userDevices] of Object.entries(deviceMap)) {
 				const isLidUser = requestedLidUsers.has(user)
-				// Process all devices for this user
+				
 				for (const item of userDevices) {
 					const finalJid = isLidUser
 						? (0, WABinary_1.jidEncode)(user, item.server, item.device)
@@ -282,7 +309,7 @@ const makeMessagesSocket = config => {
 				}
 			}
 			if (userDevicesCache.mset) {
-				// if the cache supports mset, we can set all devices in one go
+				
 				await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })))
 			} else {
 				for (const key in deviceMap) {
@@ -309,9 +336,7 @@ const makeMessagesSocket = config => {
 		}
 		return deviceResults
 	}
-	/**
-	 * Update Member Label
-	 */
+	
 	const updateMemberLabel = (jid, memberLabel) => {
 		return relayMessage(
 			jid,
@@ -340,16 +365,16 @@ const makeMessagesSocket = config => {
 	}
 	const assertSessions = async (jids, force) => {
 		let didFetchNewSession = false
-		const uniqueJids = [...new Set(jids)] // Deduplicate JIDs
+		const uniqueJids = [...new Set(jids)] 
 		const jidsRequiringFetch = []
 		logger.debug({ jids }, 'assertSessions call with jids')
-		// Check peerSessionsCache and validate sessions using libsignal loadSession
+		
 		for (const jid of uniqueJids) {
 			const signalId = signalRepository.jidToSignalProtocolAddress(jid)
 			const cachedSession = peerSessionsCache.get(signalId)
 			if (cachedSession !== undefined) {
 				if (cachedSession && !force) {
-					continue // Session exists in cache
+					continue 
 				}
 			} else {
 				const sessionValidation = await signalRepository.validateSession(jid)
@@ -362,7 +387,7 @@ const makeMessagesSocket = config => {
 			jidsRequiringFetch.push(jid)
 		}
 		if (jidsRequiringFetch.length) {
-			// LID if mapped, otherwise original; interop JIDs pass through as-is
+			
 			const wireJids = [
 				...jidsRequiringFetch.filter(jid => !!(0, WABinary_1.isLidUser)(jid) || !!(0, WABinary_1.isHostedLidUser)(jid)),
 				...(
@@ -405,7 +430,7 @@ const makeMessagesSocket = config => {
 			}
 			await (0, Utils_1.parseAndInjectE2ESessions)(result, signalRepository)
 			didFetchNewSession = true
-			// Cache fetched sessions using wire JIDs
+			
 			for (const wireJid of wireJids) {
 				const signalId = signalRepository.jidToSignalProtocolAddress(wireJid)
 				peerSessionsCache.set(signalId, true)
@@ -414,7 +439,7 @@ const makeMessagesSocket = config => {
 		return didFetchNewSession
 	}
 	const sendPeerDataOperationMessage = async pdoMessage => {
-		//TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
+		
 		if (!authState.creds.me?.id) {
 			throw new boom_1.Boom('Not authenticated')
 		}
@@ -507,7 +532,9 @@ const makeMessagesSocket = config => {
 			additionalNodes,
 			useUserDevicesCache,
 			useCachedGroupMetadata,
-			statusJidList
+			statusJidList,
+			statusPrivacy,
+			AI = false
 		}
 	) => {
 		const meId = authState.creds.me.id
@@ -523,8 +550,7 @@ const makeMessagesSocket = config => {
 		const isInterop = (0, WABinary_1.isInteropUser)(jid)
 		const isGroupOrStatus = isGroup || isStatus
 		const finalJid = jid
-		const iosBros = config.browser[0] === "iOS" || config.browser[1] === "Safari";
-	    msgId = iosBros ? Utils_1.generateIOSMessageID() : msgId ?? (0, Utils_1.generateMessageIDV2)(meId)
+		msgId = msgId || (0, Utils_1.generateMessageIDV2)(meId)
 		useUserDevicesCache = useUserDevicesCache !== false
 		useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus
 		const participants = []
@@ -547,6 +573,18 @@ const makeMessagesSocket = config => {
 
 		const buttonType = getButtonType(messages)
 		const pollMessage = messages.pollCreationMessage || messages.pollCreationMessageV2 || messages.pollCreationMessageV3
+
+		if (participant) {
+			if (!isGroup && !isStatus) {
+				additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
+			}
+			const { user, device } = (0, WABinary_1.jidDecode)(participant.jid)
+			devices.push({
+				user,
+				device,
+				jid: participant.jid
+			})
+		}
 		await authState.keys.transaction(async () => {
 			const mediaType = getMediaType(message)
 			if (mediaType) {
@@ -578,35 +616,24 @@ const makeMessagesSocket = config => {
 				(0, Utils_1.normalizeMessageContent)(message)?.pinInChatMessage ||
 				(0, Utils_1.normalizeMessageContent)(message)?.reactionMessage
 			) {
-				extraAttrs['decrypt-fail'] = 'hide' // todo: expand for reactions and other types
+				extraAttrs['decrypt-fail'] = 'hide'
 			}
 			if (isGroupOrStatus && !isRetryResend) {
 				const [groupData, senderKeyMap] = await Promise.all([
 					(async () => {
-						let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined
-						const looksStale =
-							groupData &&
-							typeof groupData.size === 'number' &&
-							Array.isArray(groupData.participants) &&
-							groupData.participants.length < groupData.size
-						if (groupData && Array.isArray(groupData?.participants) && !looksStale) {
+						let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined 
+						if (groupData && Array.isArray(groupData?.participants)) {
 							logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata')
 						} else if (!isStatus) {
-							if (looksStale) {
-								logger.debug(
-									{ jid, cached: groupData.participants.length, expected: groupData.size },
-									'cached group metadata looks stale, re-fetching'
-								)
-							}
-							groupData = await groupMetadata(jid) // TODO: start storing group participant list + addr mode in Signal & stop relying on this
+							groupData = await groupMetadata(jid) 
 						}
 						return groupData
 					})(),
 					(async () => {
 						if (!participant && !isStatus) {
-							// what if sender memory is less accurate than the cached metadata
-							// on participant change in group, we should do sender memory manipulation
-							const result = await authState.keys.get('sender-key-memory', [jid]) // TODO: check out what if the sender key memory doesn't include the LID stuff now?
+							
+							
+							const result = await authState.keys.get('sender-key-memory', [jid]) 
 							return result[jid] || {}
 						}
 						return {}
@@ -790,8 +817,8 @@ const makeMessagesSocket = config => {
 						!(0, WABinary_1.isHostedPnUser)(deviceJid) &&
 						device.device !== 99
 					) {
-						//todo: revamp all this logic
-						// the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
+						
+						
 						senderKeyRecipients.push(deviceJid)
 						senderKeyMap[deviceJid] = true
 					}
@@ -817,8 +844,8 @@ const makeMessagesSocket = config => {
 				})
 				await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } })
 			} else {
-				// ADDRESSING CONSISTENCY: Match own identity to conversation context
-				// TODO: investigate if this is true
+				
+				
 				let ownId = meId
 				if (isLid && meLid) {
 					ownId = meLid
@@ -838,9 +865,9 @@ const makeMessagesSocket = config => {
 					devices.push({
 						user,
 						device: 0,
-						jid: (0, WABinary_1.jidEncode)(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
+						jid: (0, WABinary_1.jidEncode)(user, targetUserServer, 0) 
 					})
-					// Interop contacts don't receive a copy to own devices — native WA sends only one flat <enc>
+					
 					if (user !== ownUser && !isInterop) {
 						const ownUserServer = isLid ? 'lid' : 's.whatsapp.net'
 						const ownUserForAddressing =
@@ -852,14 +879,14 @@ const makeMessagesSocket = config => {
 						})
 					}
 					if (additionalAttributes?.['category'] !== 'peer' && !isInterop) {
-						// Clear placeholders and enumerate actual devices
+						
 						devices.length = 0
-						// Use conversation-appropriate sender identity
+						
 						const senderIdentity =
 							isLid && meLid
 								? (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(meLid)?.user, 'lid', undefined)
 								: (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(meId)?.user, 's.whatsapp.net', undefined)
-						// Enumerate devices for sender and target with consistent addressing
+						
 						const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false)
 						devices.push(...sessionDevices)
 						logger.debug(
@@ -877,25 +904,26 @@ const makeMessagesSocket = config => {
 				const { user: mePnUser } = (0, WABinary_1.jidDecode)(meId)
 				const { user: meLidUser } = meLid ? (0, WABinary_1.jidDecode)(meLid) : { user: null }
 				for (const { user, jid } of devices) {
-                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
-                    if (isExactSenderDevice) continue;
-                    const isMe = user === mePnUser || user === meLidUser;
-                    let ptcp = false;
-                    if (participant) {
-                        if (!(!isMe)) ptcp = true;
-                    }
-                    if (!ptcp) {
-                        if (isMe) meRecipients.push(jid);
-                        else otherRecipients.push(jid);
-                        allRecipients.push(jid);
-                    }
-                }
+					const isExactSenderDevice = jid === meId || (meLid && jid === meLid)
+					if (isExactSenderDevice) {
+						logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)')
+						continue
+					}
+					
+					const isMe = user === mePnUser || user === meLidUser
+					if (isMe) {
+						meRecipients.push(jid)
+					} else {
+						otherRecipients.push(jid)
+					}
+					allRecipients.push(jid)
+				}
 				await assertSessions(allRecipients)
 				const [
 					{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 },
 					{ nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }
 				] = await Promise.all([
-					// For own devices: use DSM if available (1:1 chats only)
+					
 					createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
 					createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
 				])
@@ -906,15 +934,40 @@ const makeMessagesSocket = config => {
 				}
 				shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2
 			}
+			if (isRetryResend) {
+				const isParticipantLid = (0, WABinary_1.isLidUser)(participant.jid)
+				const isMe = (0, WABinary_1.areJidsSameUser)(participant.jid, isParticipantLid ? meLid : meId)
+				const encodedMessageToSend = isMe
+					? (0, Utils_1.encodeWAMessage)({
+							deviceSentMessage: {
+								destinationJid,
+								message
+							}
+						})
+					: (0, Utils_1.encodeWAMessage)(message)
+				const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
+					data: encodedMessageToSend,
+					jid: participant.jid
+				})
+				binaryNodeContent.push({
+					tag: 'enc',
+					attrs: {
+						v: '2',
+						type,
+						count: (participant.count ?? 0).toString()
+					},
+					content: encryptedContent
+				})
+			}
 			if (participants.length) {
 				if (additionalAttributes?.['category'] === 'peer') {
 					const peerNode = participants[0]?.content?.[0]
 					if (peerNode) {
-						binaryNodeContent.push(peerNode) // push only enc
+						binaryNodeContent.push(peerNode) 
 					}
 				} else if (isInterop) {
-					// Flat <enc> directly on <message> — no <participants> wrapper (native WA behavior).
-					// Find the enc for the actual interop recipient, not own-device DSM copy.
+					
+					
 					const recipientNode = participants.find(p => (0, WABinary_1.isInteropUser)(p?.attrs?.jid))
 					const encNode = (recipientNode ?? participants[0])?.content?.[0]
 					if (encNode) {
@@ -938,6 +991,22 @@ const makeMessagesSocket = config => {
 				},
 				content: binaryNodeContent
 			}
+			
+			
+			
+			if (participant) {
+				if ((0, WABinary_1.isJidGroup)(destinationJid)) {
+					stanza.attrs.to = destinationJid
+					stanza.attrs.participant = participant.jid
+				} else if ((0, WABinary_1.areJidsSameUser)(participant.jid, meId)) {
+					stanza.attrs.to = participant.jid
+					stanza.attrs.recipient = destinationJid
+				} else {
+					stanza.attrs.to = participant.jid
+				}
+			} else {
+				stanza.attrs.to = destinationJid
+			}
 			if (shouldIncludeDeviceIdentity) {
 				stanza.content.push({
 					tag: 'device-identity',
@@ -954,6 +1023,14 @@ const makeMessagesSocket = config => {
 				})
 			}
 
+			
+			if (isStatus && statusPrivacy && !additionalAttributes?.edit) {
+				stanza.content.push({
+					tag: 'meta',
+					attrs: { status_setting: statusPrivacy, session_scope: 'status' }
+				})
+			}
+
 			if (pollMessage || messages.eventMessage) {
 				stanza.content.push({
 					tag: 'meta',
@@ -1011,30 +1088,30 @@ const makeMessagesSocket = config => {
 					stanza.content.push(buttonsNode)
 				}
 			}
-			if (!config.aiLabel && (0, WABinary_1.isPnUser)(destinationJid)) {
+			if (!AI && (0, WABinary_1.isPnUser)(destinationJid)) {
 				const alreadyHasBizBot =
 					WABinary_1.getBinaryFilteredBizBot(additionalNodes || []) ||
 					WABinary_1.getBinaryFilteredBizBot(stanza.content)
 				if (!alreadyHasBizBot) {
 					stanza.content.push({ tag: 'bot', attrs: { biz_bot: '1' } })
 				}
-			} else if (config.aiLabel && !isGroup && !isStatus && !isNewsletter) {
+			} else if (AI && !isGroup && !isStatus && !isNewsletter) {
 				const existingBizBot = WABinary_1.getBinaryFilteredBizBot(additionalNodes || [])
 				if (!existingBizBot) {
 					stanza.content.push({ tag: 'bot', attrs: { biz_bot: '1' } })
 				}
 			}
-			// WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
+			
 			const isPeerMessage = additionalAttributes?.['category'] === 'peer'
 			const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage
-			// Resolve destination to LID for tctoken storage — matches Signal session key pattern
+			
 			const tcTokenJid = is1on1Send
 				? await (0, tc_token_utils_1.resolveTcTokenJid)(destinationJid, getLIDForPN)
 				: destinationJid
 			const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {}
 			const existingTokenEntry = contactTcTokenData[tcTokenJid]
 			let tcTokenBuffer = existingTokenEntry?.token
-			// Treat expired tokens the same as missing — clear from cache
+			
 			if (tcTokenBuffer?.length && (0, tc_token_utils_1.isTcTokenExpired)(existingTokenEntry?.timestamp)) {
 				logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing')
 				tcTokenBuffer = undefined
@@ -1055,17 +1132,38 @@ const makeMessagesSocket = config => {
 					content: tcTokenBuffer
 				})
 			}
+			
+			if (is1on1Send && !tcTokenBuffer?.length) {
+				try {
+					const saltStore = await authState.keys.get('nct-salt', ['default'])
+					const nctSalt = saltStore?.['default']
+					if (nctSalt?.length) {
+						const recipientLid = await getLIDForPN(destinationJid)
+						if (recipientLid) {
+							const { createHmac } = require('crypto')
+							const lidStr = (0, WABinary_1.isLidUser)(recipientLid)
+								? recipientLid
+								: `${recipientLid.split('@')[0]}@lid`
+							const cs = createHmac('sha256', nctSalt).update(lidStr, 'utf8').digest()
+							stanza.content.push({ tag: 'cstoken', attrs: {}, content: cs })
+							logger.debug({ jid: destinationJid, lid: lidStr }, 'nct: attached cstoken')
+						}
+					}
+				} catch (err) {
+					logger.debug({ jid: destinationJid, err: err?.message }, 'nct: cstoken attach failed')
+				}
+			}
 			if (additionalNodes && additionalNodes.length > 0 && !didPushAdditional) {
 				stanza.content.push(...additionalNodes)
 			}
 			logger.debug({ msgId }, `sending message to ${participants.length} devices`)
 			await sendNode(stanza)
-			// Register messageSecret immediately at send time so msmsg replies can be
-			// decrypted even if they arrive before our own message echo comes back.
+			
+			
 			if (message.messageContextInfo?.messageSecret) {
 				setBotMessageSecret(msgId, message.messageContextInfo.messageSecret, destinationJid)
 			}
-			// Fire-and-forget: issue our token to the contact AFTER message send.
+			
 			const isProtocolMsg = !!(0, Utils_1.normalizeMessageContent)(message)?.protocolMessage
 			const isBotOrPSA =
 				destinationJid === WABinary_1.PSA_WID ||
@@ -1116,7 +1214,7 @@ const makeMessagesSocket = config => {
 						inFlightTcTokenIssuance.delete(tcTokenJid)
 					})
 			}
-			// Add message to retry cache if enabled
+			
 			if (messageRetryManager && !participant) {
 				messageRetryManager.addRecentMessage(destinationJid, msgId, message)
 			}
@@ -1238,7 +1336,7 @@ const makeMessagesSocket = config => {
 				}
 			}
 		} else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
-			// Only works for WhatsApp Original, not WhatsApp Business
+			
 			return {
 				tag: 'biz',
 				attrs: {
@@ -1272,7 +1370,7 @@ const makeMessagesSocket = config => {
 				]
 			}
 		} else if (nativeFlow || message.buttonsMessage) {
-			// It works for whatsapp original and whatsapp business
+			
 			return {
 				tag: 'biz',
 				attrs: {
@@ -1368,7 +1466,7 @@ const makeMessagesSocket = config => {
 	}
 	const getPrivacyTokens = issuePrivacyTokens
 	const waUploadToServer = (0, Utils_1.getWAUploadToServer)(config, refreshMediaConn)
-	const interactiveHandler = new interactive_handler_1.InteractiveMessageHandler(waUploadToServer, relayMessage, config, sock)
+	const badzzne2 = new interactive_handler_1.badzz88(waUploadToServer, relayMessage, config, sock)
 	const waitForMsgMediaUpdate = (0, Utils_1.bindWaitForEvent)(ev, 'messages.media-update')
 	return {
 		...sock,
@@ -1521,6 +1619,7 @@ const makeMessagesSocket = config => {
 								mediaHandle = up.handle
 								return up
 							},
+							mediaAbProps: authState.creds.mediaAbProps,
 							...options
 						}
 					)
@@ -1542,6 +1641,7 @@ const makeMessagesSocket = config => {
 								mediaHandle = up.handle
 								return up
 							},
+							mediaAbProps: authState.creds.mediaAbProps,
 							...options
 						}
 					)
@@ -1561,7 +1661,7 @@ const makeMessagesSocket = config => {
 		},
 
 		sendStatusMention: async (content, jids = []) => {
-			return await interactiveHandler.sendStatusWhatsApp(content, jids)
+			return await badzzne2.sendStatusWhatsApp(content, jids)
 		},
 		sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
 			const { message, messageId } = message_composer_1.generateTableContent(title, headers, rows, quoted, options)
@@ -1616,9 +1716,7 @@ const makeMessagesSocket = config => {
 		},
 		sendMessage: async (jid, content, options = {}) => {
 			const userJid = authState.creds.me.id
-			const iosBros = config.browser[0] === "iOS" || config.browser[1] === "Safari";
-	        const mId = iosBros ? Utils_1.generateIOSMessageID() : msgId ?? (0, Utils_1.generateMessageIDV2)(userJid)
-			// ── Normalize: buttons[].nativeFlowInfo -> interactiveButtons ──────
+			
 			if (
 				typeof content === 'object' &&
 				Array.isArray(content.buttons) &&
@@ -1643,6 +1741,181 @@ const makeMessagesSocket = config => {
 				const { buttons, headerType, viewOnce, ...rest } = content
 				content = { ...rest, interactiveButtons }
 			}
+			if (
+				typeof content === 'object' &&
+				Array.isArray(content.interactiveButtons) &&
+				content.interactiveButtons.length > 0
+			) {
+				const {
+					text = '',
+					caption = '',
+					title = '',
+					footer = '',
+					interactiveButtons,
+					hasMediaAttachment = false,
+					image = null,
+					video = null,
+					document = null,
+					mimetype = null,
+					jpegThumbnail = null,
+					location = null,
+					product = null,
+					businessOwnerJid = null,
+					externalAdReply = null
+				} = content
+				
+				const processedButtons = []
+				for (let i = 0; i < interactiveButtons.length; i++) {
+					const btn = interactiveButtons[i]
+					if (!btn || typeof btn !== 'object') throw new Error(`interactiveButtons[${i}] must be an object`)
+					if (btn.name && btn.buttonParamsJson) {
+						processedButtons.push(btn)
+						continue
+					}
+					if (btn.id || btn.text || btn.displayText) {
+						processedButtons.push({
+							name: 'quick_reply',
+							buttonParamsJson: JSON.stringify({
+								display_text: btn.text || btn.displayText || `Button ${i + 1}`,
+								id: btn.id || `quick_${i + 1}`
+							})
+						})
+						continue
+					}
+					if (btn.buttonId && btn.buttonText?.displayText) {
+						processedButtons.push({
+							name: 'quick_reply',
+							buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId })
+						})
+						continue
+					}
+					throw new Error(`interactiveButtons[${i}] has invalid shape`)
+				}
+				let messageContent = {}
+				if (image) {
+					const mi = Buffer.isBuffer(image)
+						? { image }
+						: { image: { url: typeof image === 'object' ? image.url : image } }
+					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
+					messageContent.header = { title: title || '', hasMediaAttachment: true, imageMessage: pm.imageMessage }
+				} else if (video) {
+					const mi = Buffer.isBuffer(video)
+						? { video }
+						: { video: { url: typeof video === 'object' ? video.url : video } }
+					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
+					messageContent.header = { title: title || '', hasMediaAttachment: true, videoMessage: pm.videoMessage }
+				} else if (document) {
+					const mi = Buffer.isBuffer(document)
+						? { document }
+						: { document: { url: typeof document === 'object' ? document.url : document } }
+					if (mimetype && typeof mi.document === 'object') mi.document.mimetype = mimetype
+					if (jpegThumbnail) {
+						const thumb = Buffer.isBuffer(jpegThumbnail)
+							? jpegThumbnail
+							: await (async () => {
+									try {
+										const r = await fetch(jpegThumbnail)
+										return Buffer.from(await r.arrayBuffer())
+									} catch {
+										return undefined
+									}
+								})()
+						if (thumb) mi.document.jpegThumbnail = thumb
+					}
+					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
+					messageContent.header = { title: title || '', hasMediaAttachment: true, documentMessage: pm.documentMessage }
+				} else if (location && typeof location === 'object') {
+					messageContent.header = {
+						title: title || location.name || 'Location',
+						hasMediaAttachment: false,
+						locationMessage: {
+							degreesLatitude: location.degreesLatitude || location.degressLatitude || 0,
+							degreesLongitude: location.degreesLongitude || location.degressLongitude || 0,
+							name: location.name || '',
+							address: location.address || ''
+						}
+					}
+				} else if (product && typeof product === 'object') {
+					let productImageMessage = null
+					if (product.productImage) {
+						const mi = Buffer.isBuffer(product.productImage)
+							? { image: product.productImage }
+							: {
+									image: {
+										url: typeof product.productImage === 'object' ? product.productImage.url : product.productImage
+									}
+								}
+						const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
+						productImageMessage = pm.imageMessage
+					}
+					messageContent.header = {
+						title: title || product.title || 'Product',
+						hasMediaAttachment: false,
+						productMessage: {
+							product: {
+								productImage: productImageMessage,
+								productId: product.productId || '',
+								title: product.title || '',
+								description: product.description || '',
+								currencyCode: product.currencyCode || 'USD',
+								priceAmount1000: parseInt(product.priceAmount1000, 10) || 0,
+								retailerId: product.retailerId || '',
+								url: product.url || '',
+								productImageCount: product.productImageCount || 1
+							},
+							businessOwnerJid: businessOwnerJid || product.businessOwnerJid || userJid
+						}
+					}
+				} else if (title) {
+					messageContent.header = { title, hasMediaAttachment: false }
+				}
+				const hasMedia = !!(image || video || document || location || product)
+				const bodyText = hasMedia ? caption : text || caption
+				if (bodyText) messageContent.body = { text: bodyText }
+				if (footer) messageContent.footer = { text: footer }
+				messageContent.nativeFlowMessage = { buttons: processedButtons }
+				if (externalAdReply && typeof externalAdReply === 'object') {
+					messageContent.contextInfo = {
+						externalAdReply: {
+							title: externalAdReply.title || '',
+							body: externalAdReply.body || '',
+							mediaType: externalAdReply.mediaType || 1,
+							sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || '',
+							thumbnailUrl: externalAdReply.thumbnailUrl || externalAdReply.thumbnail || '',
+							renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+							showAdAttribution: externalAdReply.showAdAttribution !== false,
+							containsAutoReply: externalAdReply.containsAutoReply || false,
+							...(externalAdReply.mediaUrl && { mediaUrl: externalAdReply.mediaUrl }),
+							...(Buffer.isBuffer(externalAdReply.thumbnail) && { thumbnail: externalAdReply.thumbnail }),
+							...(externalAdReply.jpegThumbnail && { jpegThumbnail: externalAdReply.jpegThumbnail })
+						},
+						...(options.mentionedJid && { mentionedJid: options.mentionedJid })
+					}
+				} else if (options.mentionedJid) {
+					messageContent.contextInfo = { mentionedJid: options.mentionedJid }
+				}
+				const payload = index_js_1.proto.Message.InteractiveMessage.create(messageContent)
+				const msg = (0, Utils_1.generateWAMessageFromContent)(
+					jid,
+					{ viewOnceMessage: { message: { interactiveMessage: payload } } },
+					{ userJid, quoted: options?.quoted || null }
+				)
+				const additionalNodes = [
+					{
+						tag: 'biz',
+						attrs: {},
+						content: [
+							{
+								tag: 'interactive',
+								attrs: { type: 'native_flow', v: '1' },
+								content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+							}
+						]
+					}
+				]
+				await relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes })
+				return msg
+			}
 			if (
 				typeof content === 'object' &&
 				'disappearingMessagesInChat' in content &&
@@ -1657,25 +1930,25 @@ const makeMessagesSocket = config => {
 							: 0
 						: disappearingMessagesInChat
 				await groupToggleEphemeral(jid, value)
-			} else if (interactiveHandler.detectType(content)) {
+			} else if (badzzne2.detectType(content)) {
 				const { quoted } = options
-				const messageType = interactiveHandler.detectType(content)
+				const messageType = badzzne2.detectType(content)
 				switch (messageType) {
 					case 'PAYMENT': {
-						const paymentContent = await interactiveHandler.handlePayment(content, quoted)
+						const paymentContent = await badzzne2.handlePayment(content, quoted)
 						return await relayMessage(jid, paymentContent, {
-							messageId: mId
+							messageId: (0, Utils_1.generateMessageIDV2)(userJid)
 						})
 					}
 					case 'PRODUCT': {
-						const productContent = await interactiveHandler.handleProduct(content, jid, quoted)
+						const productContent = await badzzne2.handleProduct(content, jid, quoted)
 						const productMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, productContent, { quoted, userJid })
 						return await relayMessage(jid, productMsg.message, {
 							messageId: productMsg.key.id
 						})
 					}
 					case 'INTERACTIVE': {
-						const interactiveContent = await interactiveHandler.handleInteractive(content, jid, quoted)
+						const interactiveContent = await badzzne2.handleInteractive(content, jid, quoted)
 						const interactiveMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, interactiveContent, {
 							quoted,
 							userJid
@@ -1684,21 +1957,25 @@ const makeMessagesSocket = config => {
 							messageId: interactiveMsg.key.id
 						})
 					}
+					case 'INTERACTIVE_BUTTONS': {
+						const ibContent = await badzzne2.handleInteractiveButtons(content, jid, quoted)
+						const ibMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, ibContent, { quoted, userJid })
+						return await relayMessage(jid, ibMsg.message, {
+							messageId: ibMsg.key.id
+						})
+					}
 					case 'ALBUM':
-						return await interactiveHandler.handleAlbum(content, jid, quoted)
+						return await badzzne2.handleAlbum(content, jid, quoted)
 					case 'EVENT':
-						return await interactiveHandler.handleEvent(content, jid, quoted)
+						return await badzzne2.handleEvent(content, jid, quoted)
 					case 'POLL_RESULT':
-						return await interactiveHandler.handlePollResult(content, jid, quoted)
+						return await badzzne2.handlePollResult(content, jid, quoted)
 					case 'GROUP_STORY':
-						return await interactiveHandler.handleGroupStory(content, jid, quoted)
-					case 'ORDER':
-						return await interactiveHandler.handleOrderMessage(content, jid, quoted)
-					case 'GROUP_LABEL':
-						return await interactiveHandler.handleGbLabel(content, jid)
+						return await badzzne2.handleGroupStory(content, jid, quoted)
 				}
 			} else {
 				let mediaHandle
+				const { ai, ...optionsWithoutAI } = options
 				const fullMsg = await (0, Utils_1.generateWAMessage)(jid, content, {
 					logger,
 					userJid,
@@ -1712,7 +1989,6 @@ const makeMessagesSocket = config => {
 							logger,
 							uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
 						}),
-					//TODO: CACHE
 					getProfilePicUrl: sock.profilePictureUrl,
 					getCallLink: sock.createCallLink,
 					newsletter: (0, WABinary_1.isJidNewsletter)(jid),
@@ -1726,8 +2002,10 @@ const makeMessagesSocket = config => {
 					},
 					mediaCache: config.mediaCache,
 					options: config.options,
-					messageId: mId,
-					...options
+					messageId: (0, Utils_1.generateMessageIDV2)(sock.user?.id),
+					
+					mediaAbProps: authState.creds.mediaAbProps,
+					...optionsWithoutAI
 				})
 				if (!mediaHandle) {
 					const msgContent = fullMsg.message
@@ -1754,6 +2032,9 @@ const makeMessagesSocket = config => {
 					} else {
 						additionalAttributes.edit = '7'
 					}
+					if (content.delete?.server_id) {
+						additionalAttributes.server_id = String(content.delete.server_id)
+					}
 				} else if (isEditMsg) {
 					additionalAttributes.edit = '1'
 				} else if (isPinMsg) {
@@ -1792,7 +2073,9 @@ const makeMessagesSocket = config => {
 					useCachedGroupMetadata: options.useCachedGroupMetadata,
 					additionalAttributes,
 					statusJidList: options.statusJidList,
-					additionalNodes
+					statusPrivacy: options.statusPrivacy,
+					additionalNodes,
+					AI: ai || false
 				})
 				if (config.emitOwnEvents) {
 					process.nextTick(async () => {
@@ -1802,52 +2085,71 @@ const makeMessagesSocket = config => {
 				return fullMsg
 			}
 		},
-		sendMessageMembers: async (jid, message, options = {}) => {
-            const {
-                messageId: idm,
-                quoted,
-                delayMs = 1500,
-                useUserDevicesCache = true,
-                cachedGroupMetadata,
-                onlyMember = true
-            } = options;
-            const { server } = jidDecode(jid);
-            if (server !== "g.us") throw new Error("@g.us server required");
-            const meId = authState.creds.me.id;
-            const messages = Utils_1.normalizeMessageContent(message);
-            const groupData = cachedGroupMetadata? await cachedGroupMetadata(jid) : await groupMetadata(jid);
-            const isLid = groupData.addressingMode === "lid";
-            const isAdmin = groupData.participants.filter((x) => x.admin !== null).map((y) => y.id)
-            let participantJids = groupData.participants.map(z => z.id);
-            if (onlyMember) {
-                participantJids = isAdmin ? isAdmin : participantJids;
-            }
-            logger.info(`Sending message to ${participantJids.length} members from ${jid}`);
-            for (let i = 0; i < participantJids.length; i++) {
-                const jid = participantJids[i];
-                if (areJidsSameUser(jid, meId)) continue;
-                try {
-                    const msgId = `${idm || Utils_1.generateMessageID()}_${i}`;
-                    const fullMsg = await Utils_1.generateWAMessageFromContent(jid, message, {
-                        messageId: msgId,
-                        quoted
-                    })
-                    await relayMessage(jid, fullMsg.message, {
-                        messageId: fullMsg.key.id
-                    });
-                    logger.debug(`Message successfully sent to ${jid}`);
-                    if (delayMs && i < participantJids.length - 1) {
-                        await new Promise(z => setTimeout(z, delayMs));
-                    }
-                } catch (e) {
-                    logger.error({ jid, e }, "Error sending message to");
-                }
-            }
-            return JSON.stringify({
-                members_total: participantJids.length,
-                message
-            }, null, 4);
-        }
+
+		sendMetaAI: async (jid1, text, opts = {}) => {
+			const crypto = require('crypto')
+			const { proto } = require('../../WAProto/index.js')
+			const META_AI_BOT_JID = '867051314767696@bot'
+			const yourJid = jid1 || ''
+			const jid = opts.jid || META_AI_BOT_JID
+			const threadId = opts.threadId || Utils_1.generateMessageIDV2(yourJid)
+			const now = Date.now()
+			const senderTimestamp = opts.senderTimestamp || String(Math.floor(now / 1000))
+			const messageSecret = opts.messageSecret || crypto.randomBytes(32)
+			const senderKeyHash = opts.senderKeyHash || crypto.randomBytes(8).toString('base64')
+			const message = {
+				extendedTextMessage: proto.Message.ExtendedTextMessage.fromObject({
+					text,
+					previewType: 'NONE',
+					contextInfo: proto.ContextInfo.fromObject({
+						botMessageSharingInfo: {
+							botEntryPointOrigin: 'FAVICON',
+							forwardScore: 0
+						}
+					}),
+					inviteLinkGroupTypeV2: 'DEFAULT'
+				}),
+				messageContextInfo: proto.MessageContextInfo.fromObject({
+					deviceListMetadata: {
+						senderKeyHash,
+						senderTimestamp
+					},
+					deviceListMetadataVersion: 2,
+					messageSecret,
+					botMetadata: {
+						botModeSelectionMetadata: {
+							overrideMode: [0]
+						},
+						botThreadInfo: {
+							serverInfo: { title: text.substring(0, 50) },
+							clientInfo: { type: 'DEFAULT' }
+						},
+						botRenderingConfigMetadata: {
+							bloksVersioningId: '1eb86e6f4117d052e6bab62fe758a2e2af43747b85c5c1a886c8262bac462ea4',
+							pixelDensity: 2.625
+						}
+					},
+					threadId: [
+						{
+							threadType: 'AI_THREAD',
+							threadKey: {
+								remoteJid: '0002@s.whatsapp.net',
+								fromMe: true,
+								id: threadId
+							}
+						}
+					]
+				})
+			}
+			const msgId = (0, Utils_1.generateMessageIDV2)(yourJid)
+			const messageOptions = {
+				messageId: msgId,
+				quoted: opts.quoted,
+				links: opts.links
+			}
+			await relayMessage(jid, message, messageOptions)
+			return msgId
+		}
 	}
 }
 exports.makeMessagesSocket = makeMessagesSocket