@ikyyjee/ikyysinggle 1.7.7

package/lib/Utils/jid-display-normalization.js

@@ -0,0 +1,198 @@
+/**
+ * lib/Utils/jid-display-normalization.js — turns LID (linked/privacy
+ * identifiers) back into the phone-number JID for anything you'd display
+ * or re-send, using hints from the message itself, group metadata, and the
+ * signal repository's own LID<->PN mapping (falling back to a best-effort
+ * guess only if none of those resolve it). Pure data transform, no network
+ * calls beyond the signalRepository lookup already used elsewhere in this
+ * library.
+ */
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode } from '../WABinary/index.js';
+const createLidPnDebug = logger => {
+    const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true';
+    return (phase, payload) => {
+        if (!enabled) {
+            return;
+        }
+        logger?.debug({ ...payload, phase }, 'lid->pn normalization trace');
+    };
+};
+const fallbackPnFromLidJid = jid => {
+    const decoded = jidDecode(jid);
+    const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '');
+    const user = rawUser.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    return `${user}@s.whatsapp.net`;
+};
+const toDisplayPnJid = jid => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    const decoded = jidDecode(jid);
+    if (!decoded?.user) {
+        return jid;
+    }
+    if (!isPnUser(jid) && !isHostedPnUser(jid)) {
+        return jid;
+    }
+    const user = decoded.user.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net';
+    return `${user}@${server}`;
+};
+const buildLidPnHints = key => {
+    const hints = new Map();
+    if (!key) {
+        return hints;
+    }
+    const addHint = (lid, pn) => {
+        if (!isLidUser(lid) && !isHostedLidUser(lid)) {
+            return;
+        }
+        if (!isPnUser(pn) && !isHostedPnUser(pn)) {
+            return;
+        }
+        hints.set(lid, pn);
+        const lidDecoded = jidDecode(lid);
+        const pnDecoded = jidDecode(pn);
+        if (lidDecoded?.user && pnDecoded?.user) {
+            hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`);
+        }
+    };
+    addHint(key.participant, key.participantAlt);
+    addHint(key.remoteJid, key.remoteJidAlt);
+    addHint(key.participantAlt, key.participant);
+    addHint(key.remoteJidAlt, key.remoteJid);
+    return hints;
+};
+const mergeGroupDataHints = (hints, groupData, debug) => {
+    if (!groupData?.participants?.length) {
+        return;
+    }
+    debug?.('groupData-size', { participants: groupData.participants.length });
+    for (const participant of groupData.participants) {
+        const lidCandidate = participant?.lid;
+        const idCandidate = participant?.id;
+        const pnCandidate = participant?.phoneNumber;
+        const lid = (isLidUser(lidCandidate) || isHostedLidUser(lidCandidate)
+            ? lidCandidate
+            : undefined) ||
+            (isLidUser(idCandidate) || isHostedLidUser(idCandidate) ? idCandidate : undefined);
+        const pn = (isPnUser(pnCandidate) || isHostedPnUser(pnCandidate)
+            ? pnCandidate
+            : undefined) ||
+            (isPnUser(idCandidate) || isHostedPnUser(idCandidate) ? idCandidate : undefined);
+        if (!lid || !pn) {
+            continue;
+        }
+        if ((isLidUser(lid) || isHostedLidUser(lid)) &&
+            (isPnUser(pn) || isHostedPnUser(pn))) {
+            const displayPn = toDisplayPnJid(pn);
+            hints.set(lid, displayPn);
+            const lidDecoded = jidDecode(lid);
+            if (lidDecoded?.user) {
+                hints.set(`${lidDecoded.user}@lid`, displayPn);
+            }
+            debug?.('group-hint', { lid, pn: displayPn });
+        }
+    }
+};
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    if (!isLidUser(jid) && !isHostedLidUser(jid)) {
+        return jid;
+    }
+    debug?.('input', { lid: jid });
+    const hinted = hints.get(jid);
+    if (hinted) {
+        const normalized = toDisplayPnJid(hinted);
+        debug?.('hint-exact', { lid: jid, hinted, normalized });
+        return normalized;
+    }
+    const decoded = jidDecode(jid);
+    if (decoded?.user) {
+        const userHint = hints.get(`${decoded.user}@lid`);
+        if (userHint) {
+            const normalized = toDisplayPnJid(userHint);
+            debug?.('hint-user', { lid: jid, userHint, normalized });
+            return normalized;
+        }
+    }
+    const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid);
+    if (mapped) {
+        const normalized = toDisplayPnJid(mapped);
+        debug?.('mapping', { lid: jid, mapped, normalized });
+        return normalized;
+    }
+    const fallback = fallbackPnFromLidJid(jid);
+    debug?.('fallback', { lid: jid, fallback });
+    return fallback;
+};
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            await normalizeMentionedJidsToPn(item, hints, signalRepository, debug);
+        }
+        return;
+    }
+    if (Array.isArray(node.mentionedJid)) {
+        const before = [...node.mentionedJid];
+        node.mentionedJid = await Promise.all(node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+        debug?.('mentions', { before, after: node.mentionedJid });
+    }
+    if (typeof node.participant === 'string') {
+        const before = node.participant;
+        node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug);
+        if (before !== node.participant) {
+            debug?.('participant-field', { before, after: node.participant });
+        }
+    }
+    if (typeof node.remoteJid === 'string') {
+        const before = node.remoteJid;
+        node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug);
+        if (before !== node.remoteJid) {
+            debug?.('remoteJid-field', { before, after: node.remoteJid });
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (value && typeof value === 'object') {
+            await normalizeMentionedJidsToPn(value, hints, signalRepository, debug);
+        }
+    }
+};
+export const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+    if (!Array.isArray(mentions)) {
+        return mentions;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = new Map();
+    mergeGroupDataHints(hints, groupData, debug);
+    const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+    debug('send-mentions-result', { before: mentions, after: normalized });
+    return normalized;
+};
+export const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+    if (!messageInfo?.key) {
+        return messageInfo;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = buildLidPnHints(messageInfo.key);
+    mergeGroupDataHints(hints, groupData, debug);
+    const beforeKey = { ...messageInfo.key };
+    messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug);
+    messageInfo.key.participantAlt = await normalizeToPnJid(messageInfo.key.participantAlt, hints, signalRepository, debug);
+    messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug);
+    messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug);
+    await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug);
+    debug('display-key-result', { before: beforeKey, after: messageInfo.key });
+    return messageInfo;
+};

package/lib/Utils/link-preview.js

@@ -0,0 +1,85 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+        // retries
+        let retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries += 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
+        });
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};
+//# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.js

@@ -0,0 +1,3 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+//# sourceMappingURL=logger.js.map

package/lib/Utils/lt-hash.js

@@ -0,0 +1,8 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+//# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -0,0 +1,33 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};
+//# sourceMappingURL=make-mutex.js.map

package/lib/Utils/message-composer.js

@@ -0,0 +1,273 @@
+import { proto } from '../../WAProto/index.js'
+import { generateMessageIDV2 } from './generics.js'
+
+const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as', 'const', 'let', 'var',
+    'function', 'class', 'extends', 'new', 'return', 'if', 'else', 'for',
+    'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch',
+    'finally', 'throw', 'async', 'await', 'yield', 'typeof', 'instanceof',
+    'in', 'of', 'delete', 'void', 'true', 'false', 'null', 'undefined',
+    'NaN', 'Infinity', 'this', 'super', 'static', 'get', 'set', 'debugger', 'with'
+])
+
+const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+])
+
+const LANGUAGE_KEYWORDS = {
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS
+}
+
+export var CodeHighlightType
+;(function (CodeHighlightType) {
+    CodeHighlightType[(CodeHighlightType['DEFAULT'] = 0)] = 'DEFAULT'
+    CodeHighlightType[(CodeHighlightType['KEYWORD'] = 1)] = 'KEYWORD'
+    CodeHighlightType[(CodeHighlightType['METHOD'] = 2)] = 'METHOD'
+    CodeHighlightType[(CodeHighlightType['STRING'] = 3)] = 'STRING'
+    CodeHighlightType[(CodeHighlightType['NUMBER'] = 4)] = 'NUMBER'
+    CodeHighlightType[(CodeHighlightType['COMMENT'] = 5)] = 'COMMENT'
+})(CodeHighlightType || (CodeHighlightType = {}))
+
+export var RichSubMessageType
+;(function (RichSubMessageType) {
+    RichSubMessageType[(RichSubMessageType['UNKNOWN'] = 0)] = 'UNKNOWN'
+    RichSubMessageType[(RichSubMessageType['GRID_IMAGE'] = 1)] = 'GRID_IMAGE'
+    RichSubMessageType[(RichSubMessageType['TEXT'] = 2)] = 'TEXT'
+    RichSubMessageType[(RichSubMessageType['INLINE_IMAGE'] = 3)] = 'INLINE_IMAGE'
+    RichSubMessageType[(RichSubMessageType['TABLE'] = 4)] = 'TABLE'
+    RichSubMessageType[(RichSubMessageType['CODE'] = 5)] = 'CODE'
+    RichSubMessageType[(RichSubMessageType['DYNAMIC'] = 6)] = 'DYNAMIC'
+    RichSubMessageType[(RichSubMessageType['MAP'] = 7)] = 'MAP'
+    RichSubMessageType[(RichSubMessageType['LATEX'] = 8)] = 'LATEX'
+    RichSubMessageType[(RichSubMessageType['CONTENT_ITEMS'] = 9)] = 'CONTENT_ITEMS'
+})(RichSubMessageType || (RichSubMessageType = {}))
+
+export const tokenizeCode = (codeStr, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || JS_KEYWORDS
+    const blocks = []
+    const lines = codeStr.split('\n')
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li]
+        const isLast = li === lines.length - 1
+        const nl = isLast? '' : '\n'
+        if (!line.trim()) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl })
+            continue
+        }
+        if (line.trim().startsWith('//') || line.trim().startsWith('#')) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: line + nl })
+            continue
+        }
+        const regex = /(\/\/.*$|#.*$)|(["'`](?:[^"'`\\]|\\.)*["'`])|(\b\d+(?:\.\d+)?\b)|(\b[a-zA-Z_$][\w$]*\b)|([^\s\w$"'`]+)|(\s+)/g
+        let match
+        const tokens = []
+        while ((match = regex.exec(line))!== null) {
+            const val = match[0]
+            if (match[1]) {
+                tokens.push({ highlightType: CodeHighlightType.COMMENT, codeContent: val })
+            } else if (match[2]) {
+                tokens.push({ highlightType: CodeHighlightType.STRING, codeContent: val })
+            } else if (match[3]) {
+                tokens.push({ highlightType: CodeHighlightType.NUMBER, codeContent: val })
+            } else if (match[4]) {
+                if (keywords.has(val)) {
+                    tokens.push({ highlightType: CodeHighlightType.KEYWORD, codeContent: val })
+                } else {
+                    const after = line.slice(regex.lastIndex).trimStart()
+                    if (after.startsWith('(')) {
+                        tokens.push({ highlightType: CodeHighlightType.METHOD, codeContent: val })
+                    } else {
+                        tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val })
+                    }
+                }
+            } else {
+                tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val })
+            }
+        }
+        if (tokens.length === 0) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl })
+            continue
+        }
+        const merged = []
+        for (const t of tokens) {
+            const prev = merged.length > 0? merged[merged.length - 1] : undefined
+            if (prev && prev.highlightType === t.highlightType) {
+                prev.codeContent += t.codeContent
+            } else {
+                merged.push({...t })
+            }
+        }
+        if (merged.length > 0) {
+            merged[merged.length - 1].codeContent += nl
+        }
+        blocks.push(...merged)
+    }
+    return blocks
+}
+
+export const buildRichContextInfo = (quoted, options) => {
+    const ctxInfo = {
+        forwardingScore: 1,
+        isForwarded: true,
+        forwardedAiBotMessageInfo: { botJid: options?.botJid? options.botJid : '867051314767696@bot' },
+        forwardOrigin: 4,
+       ...(options?.mentions? { mentionedJid: options.mentions } : {})
+    }
+    if (quoted?.key) {
+        ctxInfo.stanzaId = quoted.key.id
+        ctxInfo.participant = quoted.key.participant || quoted.sender || quoted.key.remoteJid
+        ctxInfo.quotedMessage = quoted.message
+    }
+    return ctxInfo
+}
+
+export const buildBotForwardedMessage = (submessages, contextInfo, unifiedResponse) => {
+    const richResponse = { messageType: 1, submessages, contextInfo }
+    if (unifiedResponse) {
+        richResponse.unifiedResponse = unifiedResponse
+    }
+    return {
+        botForwardedMessage: {
+            message: { richResponseMessage: richResponse }
+        }
+    }
+}
+
+export const generateTableContent = (title, headers, rows, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const tableRows = [{ items: headers, isHeading: true },...rows.map(row => ({ items: row.map(String) }))]
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateListContent = (title, items, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const tableRows = items.map(item => ({
+        items: Array.isArray(item)? item.map(String) : [String(item)]
+    }))
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateCodeBlockContent = (code, quoted, options = {}) => {
+    const { title, footer, language = 'javascript' } = options
+    const submessages = []
+    if (title) submessages.push({ messageType: 2, messageText: title })
+    submessages.push({
+        messageType: 5,
+        codeMetadata: { codeLanguage: language, codeBlocks: tokenizeCode(code, language) }
+    })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexContent = (quoted, options) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    const latexExpressions = expressions.map(expr => {
+        const entry = {
+            latexExpression: expr.latexExpression,
+            url: expr.url,
+            width: expr.width,
+            height: expr.height
+        }
+        if (expr.fontHeight!== undefined) entry.fontHeight = expr.fontHeight
+        if (expr.imageTopPadding!== undefined) entry.imageTopPadding = expr.imageTopPadding
+        if (expr.imageLeadingPadding!== undefined) entry.imageLeadingPadding = expr.imageLeadingPadding
+        if (expr.imageBottomPadding!== undefined) entry.imageBottomPadding = expr.imageBottomPadding
+        if (expr.imageTrailingPadding!== undefined) entry.imageTrailingPadding = expr.imageTrailingPadding
+        return entry
+    })
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    const latexExpressions = await Promise.all(
+        expressions.map(async expr => {
+            const { buffer, width, height } = await renderLatexToPng(expr.latexExpression)
+            const uploadResult = await uploadFn(buffer, 'image')
+            const imageUrl = uploadResult.url || uploadResult.directPath
+            return { latexExpression: expr.latexExpression, url: imageUrl, width, height }
+        })
+    )
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexInlineImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    if (text) submessages.push({ messageType: 2, messageText: text })
+    for (const expr of expressions) {
+        const { buffer, width, height } = await renderLatexToPng(expr.latexExpression)
+        const uploadResult = await uploadFn(buffer, 'image')
+        const imageUrl = uploadResult.url || uploadResult.directPath
+        submessages.push({
+            messageType: 3,
+            imageMetadata: {
+                imageUrl: { imagePreviewUrl: imageUrl, imageHighResUrl: imageUrl },
+                imageText: expr.latexExpression,
+                alignment: 2
+            }
+        })
+    }
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const captureUnifiedResponse = msg => {
+    const botFwd = msg?.botForwardedMessage?.message
+    if (!botFwd) return null
+    const rich = botFwd.richResponseMessage
+    if (!rich?.unifiedResponse?.data) return null
+    return {
+        unifiedResponse: { data: rich.unifiedResponse.data },
+        submessages: rich.submessages || [],
+        contextInfo: rich.contextInfo || {}
+    }
+}
+
+export const generateUnifiedResponseContent = (quoted, captured) => {
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(captured.submessages, ctxInfo, captured.unifiedResponse), messageId: generateMessageIDV2() }
+}
+
+export const generateRichMessageContent = (submessages, quoted, options) => {
+    const ctxInfo = buildRichContextInfo(quoted, options)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export {
+    JS_KEYWORDS,
+    PYTHON_KEYWORDS,
+    LANGUAGE_KEYWORDS
+}