@kelvdra/baileys 1.0.5-rc.1 → 1.0.5-rc.2

package/lib/Socket/groups.js

@@ -2,12 +2,195 @@ import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeChatsSocket } from './chats.js';
+const pickFirst = (...values) => values.find(v => typeof v === 'string' && v.length > 0);
+const preferPnJid = (primary, pn) => {
+    const normalizedPrimary = primary ? jidNormalizedUser(primary) : undefined;
+    const normalizedPn = pn ? jidNormalizedUser(pn) : undefined;
+    if (isLidUser(normalizedPrimary) && isPnUser(normalizedPn)) return normalizedPn;
+    return normalizedPrimary;
+};
+const getParticipantUsername = (attrs = {}) => pickFirst(
+    attrs.notify,
+    attrs.name,
+    attrs.short_name,
+    attrs.shortName,
+    attrs.pushname,
+    attrs.verified_name,
+    attrs.verifiedName,
+    attrs.vname
+);
+const getJidUser = (jid) => typeof jid === 'string' ? jid.split('@')[0] : undefined;
+const getContactDisplayName = (contact = {}) => pickFirst(
+    contact.name,
+    contact.notify,
+    contact.verifiedName,
+    contact.verified_name,
+    contact.pushname,
+    contact.shortName,
+    contact.short_name
+);
+const participantNameFallback = (participant = {}) => getJidUser(participant.phoneNumber || participant.jid || participant.id || participant.lid);
+const buildGroupParticipant = (attrs = {}) => {
+    const rawJid = attrs.jid ? jidNormalizedUser(attrs.jid) : undefined;
+    const rawLid = attrs.lid ? jidNormalizedUser(attrs.lid) : undefined;
+    const rawPn = pickFirst(attrs.phone_number, attrs.phoneNumber, attrs.jid_pn, attrs.participant_pn, attrs.pn);
+    const pnJid = rawPn ? jidNormalizedUser(rawPn) : undefined;
+    const id = preferPnJid(rawJid, pnJid) || pnJid || rawJid;
+    const lid = isLidUser(rawJid) ? rawJid : (isLidUser(rawLid) ? rawLid : undefined);
+    const username = getParticipantUsername(attrs);
+    const participant = {
+        id,
+        jid: id,
+        phoneNumber: isPnUser(id) ? id : undefined,
+        lid,
+        username,
+        name: username,
+        notify: attrs.notify,
+        admin: (attrs.type || null)
+    };
+    const fallback = participantNameFallback(participant);
+    return {
+        ...participant,
+        username: username || fallback,
+        name: username || fallback,
+        notify: attrs.notify || username || fallback,
+        displayName: username || fallback
+    };
+};
+const normalizeGroupMetadataJids = (metadata) => ({
+    ...metadata,
+    owner: preferPnJid(metadata.owner, metadata.ownerPn),
+    ownerLid: isLidUser(metadata.owner) ? metadata.owner : undefined,
+    subjectOwner: preferPnJid(metadata.subjectOwner, metadata.subjectOwnerPn),
+    subjectOwnerLid: isLidUser(metadata.subjectOwner) ? metadata.subjectOwner : undefined,
+    descOwner: preferPnJid(metadata.descOwner, metadata.descOwnerPn),
+    descOwnerLid: isLidUser(metadata.descOwner) ? metadata.descOwner : undefined,
+    participants: Array.isArray(metadata.participants)
+        ? metadata.participants.map(p => ({ ...p, id: preferPnJid(p.id, p.phoneNumber) || p.id, jid: preferPnJid(p.jid || p.id, p.phoneNumber) || p.jid || p.id }))
+        : []
+});
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage } = sock;
+    const { authState, ev, query, upsertMessage, executeUSyncQuery } = sock;
     const { cachedGroupMetadata } = config;
+    // Cache nama kontak dari history/contact/message event.
+    // Catatan: metadata grup dari WA sering hanya mengirim jid/lid/phone_number,
+    // jadi nama member harus diperkaya dari cache kontak lokal jika tersedia.
+    const contactNameCache = new Map();
+    const putContactName = (contact = {}) => {
+        const ids = [contact.id, contact.jid, contact.phoneNumber, contact.lid]
+            .filter(Boolean)
+            .map(jid => {
+                try { return jidNormalizedUser(jid); } catch { return jid; }
+            });
+        if (!ids.length) return;
+        const displayName = getContactDisplayName(contact);
+        const cached = {
+            ...contact,
+            displayName,
+            username: displayName || contact.username,
+            name: contact.name || displayName,
+            notify: contact.notify || displayName
+        };
+        for (const id of ids) contactNameCache.set(id, cached);
+    };
+    const getCachedContactName = (participant = {}) => {
+        const ids = [participant.id, participant.jid, participant.phoneNumber, participant.lid].filter(Boolean);
+        for (const id of ids) {
+            const normalized = (() => { try { return jidNormalizedUser(id); } catch { return id; } })();
+            const contact = contactNameCache.get(normalized);
+            const name = getContactDisplayName(contact);
+            if (name) return name;
+        }
+        return undefined;
+    };
+    const enrichGroupMetadataNames = (metadata = {}) => ({
+        ...metadata,
+        participants: Array.isArray(metadata.participants)
+            ? metadata.participants.map(participant => {
+                const cachedName = getCachedContactName(participant);
+                const displayName = pickFirst(participant.username, participant.name, participant.notify, cachedName, participantNameFallback(participant));
+                return {
+                    ...participant,
+                    username: displayName,
+                    name: displayName,
+                    notify: pickFirst(participant.notify, displayName),
+                    displayName
+                };
+            })
+            : []
+    });
+    ev.on('contacts.upsert', contacts => contacts?.forEach?.(putContactName));
+    ev.on('contacts.update', contacts => contacts?.forEach?.(putContactName));
+    ev.on('messaging-history.set', ({ contacts }) => contacts?.forEach?.(putContactName));
+    ev.on('messages.upsert', ({ messages }) => {
+        for (const msg of messages || []) {
+            const remoteJid = msg?.key?.remoteJid;
+            const participant = msg?.key?.participant;
+            const id = participant || (remoteJid && !remoteJid.endsWith('@g.us') ? remoteJid : undefined);
+            if (id && msg?.pushName) putContactName({ id, notify: msg.pushName });
+        }
+    });
     // ── Built-in group metadata cache ─────────────────────────────────────────
+
+    const fetchParticipantUsernames = async (participants = []) => {
+        // WA username (@username) beda dengan pushName/kontak.
+        // groupMetadata biasanya tidak membawa username, jadi kita query USync username.
+        // Jika akun belum punya username atau server tidak mengizinkan, hasilnya kosong.
+        const entries = participants
+            .map(p => ({ participant: p, jid: p.jid || p.id || p.phoneNumber || p.lid }))
+            .filter(({ jid }) => typeof jid === 'string' && jid.length > 0);
+        const result = new Map();
+        const chunkSize = config.groupUsernameQueryChunkSize || 50;
+        for (let i = 0; i < entries.length; i += chunkSize) {
+            const chunk = entries.slice(i, i + chunkSize);
+            try {
+                const usync = new USyncQuery().withContext('interactive').withUsernameProtocol();
+                for (const { jid } of chunk) {
+                    const normalized = (() => { try { return jidNormalizedUser(jid); } catch { return jid; } })();
+                    usync.withUser(new USyncUser().withId(normalized));
+                }
+                const res = await executeUSyncQuery(usync);
+                for (const item of res?.list || []) {
+                    const username = typeof item.username === 'string' && item.username.length > 0 ? item.username : undefined;
+                    if (username) result.set(jidNormalizedUser(item.id), username);
+                }
+            } catch (err) {
+                config.logger?.debug?.({ err }, 'failed to fetch group participant usernames');
+            }
+        }
+        return result;
+    };
+    const enrichGroupMetadataUsernames = async (metadata = {}) => {
+        const normalized = normalizeGroupMetadataJids(metadata);
+        const shouldQueryUsername = config.fetchGroupParticipantsUsername !== false;
+        const usernameMap = shouldQueryUsername ? await fetchParticipantUsernames(normalized.participants) : new Map();
+        const withNames = enrichGroupMetadataNames(normalized);
+        return {
+            ...withNames,
+            participants: withNames.participants.map(participant => {
+                const keys = [participant.jid, participant.id, participant.phoneNumber, participant.lid].filter(Boolean);
+                let waUsername;
+                for (const key of keys) {
+                    const normalizedKey = (() => { try { return jidNormalizedUser(key); } catch { return key; } })();
+                    waUsername = usernameMap.get(normalizedKey);
+                    if (waUsername) break;
+                }
+                return waUsername
+                    ? {
+                        ...participant,
+                        username: waUsername,
+                        waUsername,
+                        displayName: waUsername,
+                        name: participant.name,
+                        notify: participant.notify
+                    }
+                    : participant;
+            })
+        };
+    };
     const groupMetadataCache = new Map();
     const GROUP_CACHE_TTL = (config.groupCacheTTL || 5) * 60 * 1000; // default 5 menit
     const getCachedGroupMetadata = async (jid) => {
@@ -97,13 +280,13 @@ export const makeGroupsSocket = (config) => {
     const groupMetadata = async (jid) => {
         // Cek cache dulu sebelum hit network
         const cached = await getCachedGroupMetadata(jid);
-        if (cached) return cached;
+        if (cached) return await enrichGroupMetadataUsernames(cached);
         // Fetch dari WA
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
         const meta = extractGroupMetadata(result);
         // Simpan ke cache
         setCachedGroupMetadata(jid, meta);
-        return meta;
+        return await enrichGroupMetadataUsernames(meta);
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -134,7 +317,7 @@ export const makeGroupsSocket = (config) => {
                     attrs: {},
                     content: [groupNode]
                 });
-                data[meta.id] = meta;
+                data[meta.id] = enrichGroupMetadataNames(normalizeGroupMetadataJids(meta));
             }
         }
         // TODO: properly parse LID / PN DATA
@@ -167,7 +350,7 @@ export const makeGroupsSocket = (config) => {
                     }))
                 }
             ]);
-            return extractGroupMetadata(result);
+            return enrichGroupMetadataNames(extractGroupMetadata(result));
         },
         groupLeave: async (id) => {
             await groupQuery('@g.us', 'set', [
@@ -417,8 +600,9 @@ export const extractGroupMetadata = (result) => {
         notify: group.attrs.notify,
         addressingMode: group.attrs.addressing_mode === 'lid' ? WAMessageAddressingMode.LID : WAMessageAddressingMode.PN,
         subject: group.attrs.subject,
-        subjectOwner: group.attrs.s_o,
-        subjectOwnerPn: group.attrs.s_o_pn,
+        subjectOwner: preferPnJid(group.attrs.s_o, group.attrs.s_o_pn),
+        subjectOwnerPn: group.attrs.s_o_pn ? jidNormalizedUser(group.attrs.s_o_pn) : undefined,
+        subjectOwnerLid: isLidUser(group.attrs.s_o) ? jidNormalizedUser(group.attrs.s_o) : undefined,
         subjectTime: +group.attrs.s_t,
         size: group.attrs.size ? +group.attrs.size : getBinaryNodeChildren(group, 'participant').length,
         creation: +group.attrs.creation,
@@ -437,23 +621,9 @@ export const extractGroupMetadata = (result) => {
         isCommunityAnnounce: !!getBinaryNodeChild(group, 'default_sub_group'),
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
-        participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            const isLid = isLidUser(attrs.jid);
-            const pn = attrs.phone_number;
-            const hasPn = isPnUser(pn);
-            // Jika grup pakai LID addressing:
-            // - id   → pakai phoneNumber (PN) agar bisa dicompare dengan m.sender
-            // - lid  → simpan LID asli
-            // Jika grup pakai PN addressing: id tetap PN
-            return {
-                id: isLid && hasPn ? pn : attrs.jid,
-                phoneNumber: isLid && hasPn ? pn : undefined,
-                lid: isLid ? attrs.jid : (isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined),
-                admin: (attrs.type || null)
-            };
-        }),
+        participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => buildGroupParticipant(attrs)),
         ephemeralDuration: eph ? +eph : undefined
     };
-    return metadata;
+    return normalizeGroupMetadataJids(metadata);
 };
 //# sourceMappingURL=groups.js.map

package/lib/Socket/hydra.js

@@ -4,6 +4,183 @@ const WAProto = WaProto.proto
 import axios from "axios"
 import crypto from 'crypto'
 
+function hydraExtractHyperlink(text = '') {
+    const hyperlink = [];
+    const stack = [];
+    let result = '';
+    let last = 0;
+    let index = 1;
+    let entity = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '[' && text[i - 1] !== '\\') {
+            stack.push(i);
+        } else if (text[i] === ']' && text[i + 1] === '(') {
+            const start = stack.pop();
+            if (start == null) continue;
+
+            let end = i + 2;
+            let depth = 1;
+
+            while (end < text.length && depth) {
+                if (text[end] === '(' && text[end - 1] !== '\\') depth++;
+                else if (text[end] === ')' && text[end - 1] !== '\\') depth--;
+                end++;
+            }
+
+            if (depth) continue;
+
+            const txt = text.slice(start + 1, i).trim();
+            const url = text.slice(i + 2, end - 1);
+            const reference_id = txt ? 0 : index++;
+            const key = `HYDRA_IE_${entity++}`;
+            const tag = `{{${key}}}${txt || url || 'Link'}{{/${key}}}`;
+
+            result += text.slice(last, start) + tag;
+            last = end;
+
+            hyperlink.push({ reference_id, key, text: txt, url });
+            i = end - 1;
+        }
+    }
+
+    result += text.slice(last);
+    return { text: result, hyperlink };
+}
+
+function hydraToTableMetadata(arr = []) {
+    if (!Array.isArray(arr) || arr.length < 1) {
+        return { title: '', rows: [], unified_rows: [] };
+    }
+
+    const [header = [], ...rows] = arr;
+    const maxLen = Math.max(header.length || 0, ...rows.map((r) => Array.isArray(r) ? r.length : 0), 1);
+    const normalize = (r = []) => [...r, ...Array(maxLen - r.length).fill('')].map((x) => String(x ?? ''));
+
+    const unified_rows = [
+        { is_header: true, cells: normalize(header) },
+        ...rows.map((r) => ({ is_header: false, cells: normalize(Array.isArray(r) ? r : [r]) }))
+    ];
+
+    return {
+        title: '',
+        rows: unified_rows.map((r) => ({
+            items: r.cells,
+            ...(r.is_header ? { isHeading: true } : {})
+        })),
+        unified_rows
+    };
+}
+
+function hydraTokenizeCode(code = '', lang = 'javascript') {
+    const keywordsMap = {
+        javascript: new Set([
+            'break', 'case', 'catch', 'continue', 'debugger', 'delete', 'do', 'else',
+            'finally', 'for', 'function', 'if', 'in', 'instanceof', 'new', 'return',
+            'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with',
+            'true', 'false', 'null', 'undefined', 'class', 'const', 'let', 'super',
+            'extends', 'export', 'import', 'yield', 'static', 'constructor', 'async',
+            'await', 'get', 'set'
+        ]),
+        python: new Set([
+            'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
+            'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
+            'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',
+            'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
+        ])
+    };
+
+    const TYPE_MAP = {
+        0: 'DEFAULT',
+        1: 'KEYWORD',
+        2: 'METHOD',
+        3: 'STR',
+        4: 'NUMBER',
+        5: 'COMMENT'
+    };
+
+    const keywords = keywordsMap[lang] || keywordsMap.javascript;
+    const tokens = [];
+    let i = 0;
+
+    const push = (content, type) => {
+        if (!content) return;
+        const last = tokens[tokens.length - 1];
+        if (last && last.highlightType === type) last.codeContent += content;
+        else tokens.push({ codeContent: content, highlightType: type });
+    };
+
+    while (i < code.length) {
+        const c = code[i];
+
+        if (/\s/.test(c)) {
+            const s = i;
+            while (i < code.length && /\s/.test(code[i])) i++;
+            push(code.slice(s, i), 0);
+            continue;
+        }
+
+        if ((c === '/' && code[i + 1] === '/') || (c === '#' && lang === 'python')) {
+            const s = i;
+            i += c === '#' ? 1 : 2;
+            while (i < code.length && code[i] !== '\n') i++;
+            push(code.slice(s, i), 5);
+            continue;
+        }
+
+        if (c === '"' || c === "'" || c === '`') {
+            const s = i;
+            const q = c;
+            i++;
+            while (i < code.length) {
+                if (code[i] === '\\' && i + 1 < code.length) i += 2;
+                else if (code[i] === q) {
+                    i++;
+                    break;
+                } else i++;
+            }
+            push(code.slice(s, i), 3);
+            continue;
+        }
+
+        if (/[0-9]/.test(c)) {
+            const s = i;
+            while (i < code.length && /[0-9.]/.test(code[i])) i++;
+            push(code.slice(s, i), 4);
+            continue;
+        }
+
+        if (/[a-zA-Z_$]/.test(c)) {
+            const s = i;
+            while (i < code.length && /[a-zA-Z0-9_$]/.test(code[i])) i++;
+            const word = code.slice(s, i);
+
+            let type = 0;
+            if (keywords.has(word)) type = 1;
+            else {
+                let j = i;
+                while (j < code.length && /\s/.test(code[j])) j++;
+                if (code[j] === '(') type = 2;
+            }
+
+            push(word, type);
+            continue;
+        }
+
+        push(c, 0);
+        i++;
+    }
+
+    return {
+        codeBlock: tokens,
+        unified_codeBlock: tokens.map((t) => ({
+            content: t.codeContent,
+            type: TYPE_MAP[t.highlightType] || 'DEFAULT'
+        }))
+    };
+}
+
+
 class hydra {
     constructor(utils, waUploadToServer, relayMessageFn) {
         this.utils = utils;
@@ -23,6 +200,7 @@ class hydra {
         if (content.groupStatus) return 'GROUP_STATUS';
         if (content.carouselMessage || content.carousel) return 'CAROUSEL'; 
         if (content.stickerPack) return "STICKER_PACK";
+        if (content.aiRich || content.airich || content.richResponse || content.richResponseMessage || content.AIRich) return 'AI_RICH';
         return null;
 }
     
@@ -753,6 +931,305 @@ class hydra {
               messageId: this.utils.generateMessageID()
             });
     }
+
+    buildAIRichPayload(data = {}) {
+        const submessages = [];
+        const sections = [];
+        const richResponseSources = [];
+
+        const addText = (text = '', { hyperlink = true } = {}) => {
+            const extracted = hyperlink ? hydraExtractHyperlink(String(text ?? '')) : { text: String(text ?? ''), hyperlink: [] };
+
+            submessages.push({
+                messageType: 2,
+                messageText: extracted.text
+            });
+
+            sections.push({
+                view_model: {
+                    primitive: extracted.hyperlink.length
+                        ? {
+                            text: extracted.text,
+                            inline_entities: extracted.hyperlink.map(({ reference_id, key, text, url }) => ({
+                                key,
+                                metadata: text?.trim()
+                                    ? {
+                                        display_name: text,
+                                        is_trusted: true,
+                                        url,
+                                        __typename: 'GenAIInlineLinkItem'
+                                    }
+                                    : {
+                                        reference_id,
+                                        reference_url: url,
+                                        reference_title: url,
+                                        reference_display_name: url,
+                                        sources: [],
+                                        __typename: 'GenAISearchCitationItem'
+                                    }
+                            })),
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        }
+                        : {
+                            text: String(text ?? ''),
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        };
+
+        const addCode = (language = 'javascript', code = '') => {
+            const meta = hydraTokenizeCode(String(code ?? ''), language);
+
+            submessages.push({
+                messageType: 5,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: meta.codeBlock
+                }
+            });
+
+            sections.push({
+                view_model: {
+                    primitive: {
+                        language,
+                        code_blocks: meta.unified_codeBlock,
+                        __typename: 'GenAICodeUXPrimitive'
+                    },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        };
+
+        const addTable = (table = []) => {
+            const meta = hydraToTableMetadata(table);
+
+            submessages.push({
+                messageType: 4,
+                tableMetadata: {
+                    title: meta.title,
+                    rows: meta.rows
+                }
+            });
+
+            sections.push({
+                view_model: {
+                    primitive: {
+                        rows: meta.unified_rows,
+                        __typename: 'GenATableUXPrimitive'
+                    },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        };
+
+        const addImages = (images = []) => {
+            const list = Array.isArray(images) ? images : [images];
+            const imageUrls = list
+                .filter(Boolean)
+                .map((item) => {
+                    const url = typeof item === 'string' ? item : item.url || item.imageUrl || item.imagePreviewUrl;
+                    return {
+                        imagePreviewUrl: url,
+                        imageHighResUrl: item.imageHighResUrl || item.highResUrl || url,
+                        sourceUrl: item.sourceUrl || data.sourceUrl || 'https://google.com'
+                    };
+                })
+                .filter((x) => x.imagePreviewUrl);
+
+            if (!imageUrls.length) return;
+
+            submessages.push({
+                messageType: 1,
+                gridImageMetadata: {
+                    gridImageUrl: {
+                        imagePreviewUrl: imageUrls[0].imagePreviewUrl
+                    },
+                    imageUrls
+                }
+            });
+
+            imageUrls.forEach(({ imagePreviewUrl }) => {
+                sections.push({
+                    view_model: {
+                        primitive: {
+                            media: {
+                                url: imagePreviewUrl,
+                                mime_type: 'image/jpeg'
+                            },
+                            imagine_type: 3,
+                            status: {
+                                status: 'READY'
+                            },
+                            __typename: 'GenAIImaginePrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                });
+            });
+        };
+
+        const addSources = (sources = []) => {
+            if (!Array.isArray(sources) || !sources.length) return;
+
+            sections.push({
+                view_model: {
+                    primitive: {
+                        sources: sources.map((source) => {
+                            const arr = Array.isArray(source) ? source : null;
+                            const profileUrl = arr ? arr[0] : source.profileIconUrl || source.faviconUrl || source.thumbnailUrl || '';
+                            const url = arr ? arr[1] : source.url || source.sourceUrl || source.sourceProviderURL || '';
+                            const text = arr ? arr[2] : source.title || source.sourceTitle || source.provider || 'Source';
+
+                            return {
+                                source_type: 'THIRD_PARTY',
+                                source_display_name: text,
+                                source_subtitle: source.subtitle || 'AI',
+                                source_url: url,
+                                favicon: {
+                                    url: profileUrl,
+                                    mime_type: 'image/jpeg',
+                                    width: 16,
+                                    height: 16
+                                }
+                            };
+                        }),
+                        __typename: 'GenAISearchResultPrimitive'
+                    },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        };
+
+        const addReels = (reelsItems = []) => {
+            if (!Array.isArray(reelsItems) || !reelsItems.length) return;
+
+            submessages.push({
+                messageType: 9,
+                contentItemsMetadata: {
+                    contentType: 1,
+                    itemsMetadata: reelsItems.map((item) => ({
+                        reelItem: {
+                            title: item.title || item.creator || '',
+                            profileIconUrl: item.profileIconUrl || item.avatar_url || '',
+                            thumbnailUrl: item.thumbnailUrl || item.thumbnail_url || '',
+                            videoUrl: item.videoUrl || item.reels_url || item.url || '',
+                        }
+                    }))
+                }
+            });
+
+            reelsItems.forEach((item, idx) => {
+                richResponseSources.push({
+                    provider: item.provider || 'UNKNOWN',
+                    thumbnailCDNURL: item.thumbnailUrl || item.thumbnail_url || '',
+                    sourceProviderURL: item.videoUrl || item.reels_url || item.url || '',
+                    sourceQuery: '',
+                    faviconCDNURL: item.profileIconUrl || item.avatar_url || '',
+                    citationNumber: idx + 1,
+                    sourceTitle: item.title || item.creator || `Reel ${idx + 1}`
+                });
+            });
+
+            sections.push({
+                view_model: {
+                    primitives: reelsItems.map((item) => ({
+                        reels_url: item.videoUrl || item.reels_url || item.url || '',
+                        thumbnail_url: item.thumbnailUrl || item.thumbnail_url || '',
+                        creator: item.title || item.creator || '',
+                        avatar_url: item.profileIconUrl || item.avatar_url || '',
+                        reels_title: item.reels_title || item.reelsTitle || item.title || '',
+                        likes_count: item.likes_count || item.likesCount || 0,
+                        shares_count: item.shares_count || item.sharesCount || 0,
+                        view_count: item.view_count || item.viewCount || 0,
+                        reel_source: item.reel_source || item.reelSource || 'IG',
+                        is_verified: !!(item.is_verified ?? item.isVerified),
+                        __typename: 'GenAIReelPrimitive'
+                    })),
+                    __typename: 'GenAIHScrollLayoutViewModel'
+                }
+            });
+        };
+
+        if (data.text) addText(data.text, { hyperlink: data.hyperlink !== false });
+        if (Array.isArray(data.texts)) data.texts.forEach((text) => addText(text, { hyperlink: data.hyperlink !== false }));
+
+        if (data.code) {
+            if (typeof data.code === 'string') addCode(data.language || 'javascript', data.code);
+            else addCode(data.code.language || data.language || 'javascript', data.code.content || data.code.code || '');
+        }
+
+        if (Array.isArray(data.codes)) {
+            data.codes.forEach((item) => {
+                if (typeof item === 'string') addCode(data.language || 'javascript', item);
+                else addCode(item.language || data.language || 'javascript', item.content || item.code || '');
+            });
+        }
+
+        if (data.table) addTable(data.table);
+        if (data.image || data.images || data.gridImage) addImages(data.images || data.gridImage || data.image);
+        if (data.sources) addSources(data.sources);
+        if (data.reels || data.reel) addReels(data.reels || data.reel);
+
+        const forwarded = data.forwarded !== false;
+        const includesUnifiedResponse = data.includesUnifiedResponse !== false;
+
+        return {
+            messageContextInfo: {
+                deviceListMetadata: {},
+                deviceListMetadataVersion: 2,
+                botMetadata: {
+                    messageDisclaimerText: data.disclaimerText || data.messageDisclaimerText || '',
+                    pluginMetadata: {},
+                    richResponseSourcesMetadata: {
+                        sources: data.richResponseSources || richResponseSources
+                    }
+                }
+            },
+            botForwardedMessage: {
+                message: {
+                    richResponseMessage: {
+                        messageType: data.messageType || 1,
+                        submessages,
+                        unifiedResponse: {
+                            data: includesUnifiedResponse
+                                ? Buffer.from(JSON.stringify({
+                                    response_id: data.responseId || crypto.randomUUID(),
+                                    sections
+                                })).toString('base64')
+                                : ''
+                        },
+                        contextInfo: forwarded
+                            ? {
+                                forwardingScore: data.forwardingScore || 1,
+                                isForwarded: true,
+                                forwardedAiBotMessageInfo: {
+                                    botJid: data.botJid || '0@bot'
+                                },
+                                forwardOrigin: data.forwardOrigin || 4,
+                                ...(data.contextInfo || {})
+                            }
+                            : (data.contextInfo || {})
+                    }
+                }
+            }
+        };
+    }
+
+    async handleAIRich(content, jid, quoted, options = {}) {
+        const data = content.aiRich || content.airich || content.richResponse || content.AIRich || content;
+
+        const msg = this.buildAIRichPayload(data);
+
+        return await this.relayMessage(jid, msg, {
+            messageId: data.messageId || this.utils.generateMessageID?.() || crypto.randomBytes(10).toString('hex').toUpperCase(),
+            ...(quoted ? { quoted } : {}),
+            ...options
+        });
+    }
+
+
     }
 
 export default hydra

package/lib/Socket/messages-send.js

@@ -1270,8 +1270,35 @@ export const makeMessagesSocket = (config) => {
             }
             return album
         },
+        sendAIRich: async (jid, content = {}, options = {}) => {
+            const { quoted, filter = false } = options;
+            const getParticipantAttr = () => filter ? { participant: { jid } } : {};
+            return await kelvdra.handleAIRich({ aiRich: content }, jid, quoted, {
+                ...getParticipantAttr()
+            });
+        },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            const normalizeDeleteKey = async (key = {}) => {
+                const normalized = { ...key };
+                const resolveLid = async (value) => {
+                    if (!value || !isLidUser(value)) return value;
+                    try {
+                        return (await signalRepository?.lidMapping?.getPNForLID(value)) || value;
+                    } catch {
+                        return value;
+                    }
+                };
+                normalized.remoteJid = await resolveLid(normalized.remoteJid || jid);
+                normalized.participant = await resolveLid(normalized.participant);
+                if (isJidGroup(normalized.remoteJid || jid) && !normalized.participant) {
+                    normalized.participant = normalized.fromMe ? userJid : undefined;
+                }
+                return normalized;
+            };
+            if (content?.delete) {
+                content = { ...content, delete: await normalizeDeleteKey(content.delete) };
+            }
             const additionalAttributes = {}
             const { filter = false, quoted } = options;
             const getParticipantAttr = () => filter ? { participant: { jid } } : {};
@@ -1314,6 +1341,11 @@ export const makeMessagesSocket = (config) => {
 
         case 'CAROUSEL':
             return await kelvdra.handleCarousel(content, jid, quoted);
+                        
+        case 'AI_RICH':
+            return await kelvdra.handleAIRich(content, jid, quoted, {
+                ...getParticipantAttr()
+            });
     }
 }
             if (typeof content === 'object' &&

package/lib/Types/GroupMetadata.d.ts

@@ -1,6 +1,19 @@
 import type { Contact } from './Contact.js';
 import type { WAMessageAddressingMode } from './Message.js';
 export type GroupParticipant = Contact & {
+    /** PN/JID result. If WA returns @lid with phone_number, this is normalized to @s.whatsapp.net */
+    jid?: string;
+    /** display/notify name returned by WhatsApp participant node */
+    username?: string;
+    waUsername?: string;
+    name?: string;
+    notify?: string;
+    /** best display name after metadata/contact-cache enrichment */
+    displayName?: string;
+    /** original LID when WhatsApp returns LID addressing */
+    lid?: string;
+    /** PN JID when available */
+    phoneNumber?: string;
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
@@ -15,17 +28,20 @@ export interface GroupMetadata {
     addressingMode?: WAMessageAddressingMode;
     owner: string | undefined;
     ownerPn?: string | undefined;
+    ownerLid?: string | undefined;
     owner_country_code?: string | undefined;
     subject: string;
     /** group subject owner */
     subjectOwner?: string;
     subjectOwnerPn?: string;
+    subjectOwnerLid?: string;
     /** group subject modification date */
     subjectTime?: number;
     creation?: number;
     desc?: string;
     descOwner?: string;
     descOwnerPn?: string;
+    descOwnerLid?: string;
     descId?: string;
     descTime?: number;
     /** if this group is part of a community, it returns the jid of the community to which it belongs */

package/lib/WAUSync/Protocols/index.d.ts

@@ -2,4 +2,5 @@ export * from './USyncDeviceProtocol.js';
 export * from './USyncContactProtocol.js';
 export * from './USyncStatusProtocol.js';
 export * from './USyncDisappearingModeProtocol.js';
+export * from './USyncUsernameProtocol.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/WAUSync/Protocols/index.js

@@ -2,4 +2,5 @@ export * from './USyncDeviceProtocol.js';
 export * from './USyncContactProtocol.js';
 export * from './USyncStatusProtocol.js';
 export * from './USyncDisappearingModeProtocol.js';
+export * from './USyncUsernameProtocol.js';
 //# sourceMappingURL=index.js.map

package/lib/WAUSync/USyncQuery.js

@@ -1,7 +1,7 @@
 import { getBinaryNodeChild } from '../WABinary/index.js';
 import { USyncBotProfileProtocol } from './Protocols/UsyncBotProfileProtocol.js';
 import { USyncLIDProtocol } from './Protocols/UsyncLIDProtocol.js';
-import { USyncContactProtocol, USyncDeviceProtocol, USyncDisappearingModeProtocol, USyncStatusProtocol } from './Protocols/index.js';
+import { USyncContactProtocol, USyncDeviceProtocol, USyncDisappearingModeProtocol, USyncStatusProtocol, USyncUsernameProtocol } from './Protocols/index.js';
 import { USyncUser } from './USyncUser.js';
 export class USyncQuery {
     constructor() {
@@ -90,5 +90,9 @@ export class USyncQuery {
         this.protocols.push(new USyncLIDProtocol());
         return this;
     }
+    withUsernameProtocol() {
+        this.protocols.push(new USyncUsernameProtocol());
+        return this;
+    }
 }
 //# sourceMappingURL=USyncQuery.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kelvdra/baileys",
   "type": "module",
-  "version": "1.0.5-rc.1",
+  "version": "1.0.5-rc.2",
   "description": "Baileys fork whiskeysockets modified by kelvdra.",
   "keywords": [
     "baileys",