@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/make-mutex.js

@@ -0,0 +1,32 @@
+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);
+                }
+            }
+        }
+    };
+};

package/lib/Utils/media-messages.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generates a panoramic/wide profile picture buffer — landscape images are
+ * scaled down to a 720px-wide target, portrait images to a 324px-wide
+ * target, preserving aspect ratio throughout.
+ */
+export function generateProfilePictureFull(img: any): Promise<{
+    img: any;
+}>;
+/**
+ * Generates a panoramic/wide profile picture buffer — landscape images are
+ * scaled down to a 720px-wide target, portrait images to a 324px-wide
+ * target, preserving aspect ratio throughout.
+ */
+export function changeprofileFull(img: any): Promise<{
+    img: any;
+}>;
+/**
+ * Generates a square profile picture buffer (main image, scaled to fit
+ * within 720x720) plus a normalized preview buffer.
+ */
+export function generateProfilePictureFP(buffer: any): Promise<{
+    img: any;
+    preview: any;
+}>;
+/**
+ * Generates a square profile picture buffer (main image, scaled to fit
+ * within 720x720) plus a normalized preview buffer.
+ */
+export function generatePP(buffer: any): Promise<{
+    img: any;
+    preview: any;
+}>;
+export function generateProfilePicturee(mediaUpload: any): Promise<{
+    img: any;
+}>;

package/lib/Utils/media-messages.js

@@ -0,0 +1,70 @@
+/**
+ * ported from Bail-master addons/media-messages.ts.
+ * Jimp-based profile-picture image generators (square + panoramic/wide).
+ * Deduplicated aliases kept intact: generateProfilePictureFull ===
+ * changeprofileFull, generateProfilePictureFP === generatePP (source had
+ * these as byte-identical pairs under different names).
+ */
+import { Jimp, JimpMime } from 'jimp';
+const toBuffer = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    stream.destroy?.();
+    return Buffer.concat(chunks);
+};
+/**
+ * Generates a panoramic/wide profile picture buffer — landscape images are
+ * scaled down to a 720px-wide target, portrait images to a 324px-wide
+ * target, preserving aspect ratio throughout.
+ */
+const generateWideProfilePicture = async (img) => {
+    const jimp = await Jimp.read(img);
+    const width = jimp.bitmap.width;
+    const height = jimp.bitmap.height;
+    const ratio = width > height ? width / 720 : width / 324;
+    const targetWidth = Math.round(width / ratio);
+    const targetHeight = Math.round(height / ratio);
+    const buffer = await jimp.resize({ w: targetWidth, h: targetHeight }).getBuffer(JimpMime.jpeg, { quality: 100 });
+    return { img: buffer };
+};
+export const generateProfilePictureFull = generateWideProfilePicture;
+export const changeprofileFull = generateWideProfilePicture;
+/**
+ * Generates a square profile picture buffer (main image, scaled to fit
+ * within 720x720) plus a normalized preview buffer.
+ */
+const generateSquareProfilePicture = async (buffer) => {
+    const jimp = await Jimp.read(buffer);
+    const img = await jimp.clone().scaleToFit({ w: 720, h: 720 }).getBuffer(JimpMime.jpeg);
+    const preview = await jimp.clone().normalize().getBuffer(JimpMime.jpeg);
+    return { img, preview };
+};
+export const generateProfilePictureFP = generateSquareProfilePicture;
+export const generatePP = generateSquareProfilePicture;
+/**
+ * Generates a profile picture buffer from a flexible input source — a raw
+ * Buffer, a `{ url }` media-upload descriptor, or a `{ stream }`
+ * media-upload descriptor. Resizes the longer dimension down to 720px,
+ * preserving aspect ratio on the other.
+ */
+export const generateProfilePicturee = async (mediaUpload) => {
+    let bufferOrFilePath;
+    if (Buffer.isBuffer(mediaUpload)) {
+        bufferOrFilePath = mediaUpload;
+    }
+    else if ('url' in mediaUpload) {
+        bufferOrFilePath = mediaUpload.url.toString();
+    }
+    else {
+        bufferOrFilePath = await toBuffer(mediaUpload.stream);
+    }
+    const jimp = await Jimp.read(bufferOrFilePath);
+    const { width, height } = jimp.bitmap;
+    const resized = width > height
+        ? jimp.resize({ w: 720, h: Math.round((height / width) * 720) })
+        : jimp.resize({ w: Math.round((width / height) * 720), h: 720 });
+    const img = await resized.getBuffer(JimpMime.jpeg, { quality: 100 });
+    return { img };
+};

package/lib/Utils/media-processor.d.ts

@@ -0,0 +1,6 @@
+export declare const resizeImage: (buffer: Buffer, options?: { width?: number; height?: number; fit?: string; format?: string; quality?: number }) => Promise<Buffer>;
+export declare const convertToWhatsAppVideo: (buffer: Buffer, options?: { maxWidth?: number; videoBitrate?: string; audioBitrate?: string }) => Promise<Buffer>;
+export declare const convertToOpusAudio: (buffer: Buffer, options?: { bitrate?: string; channels?: number; sampleRate?: number }) => Promise<Buffer>;
+export declare const getVideoThumbnail: (buffer: Buffer, timeSec?: number, options?: { width?: number; height?: number }) => Promise<Buffer>;
+export declare const probeMedia: (buffer: Buffer, mimeType?: string) => Promise<any>;
+export declare const getMp4Duration: (buffer: Buffer, options?: { silent?: boolean }) => number | null;

package/lib/Utils/media-processor.js

@@ -0,0 +1,174 @@
+// Ported into @vanzxysenpai/baileys 0.0.1 from @rennzsync/baileys 10.7.4, MIT. See NOTICE.md.
+/**
+ * media-processor.js — utilitas media terpusat untuk bot WhatsApp multi-media.
+ *
+ * Semua dependency berat (sharp, fluent-ffmpeg, audio-decode) di-load secara
+ * LAZY (dynamic import) sehingga proses yang tidak memakai fitur media tidak
+ * membayar biaya RAM-nya. Jika package opsional tidak terpasang, fungsi yang
+ * membutuhkannya melempar error yang jelas.
+ */
+import { PassThrough, Readable } from 'stream';
+
+const loadSharp = async () => {
+    try {
+        return (await import('sharp')).default;
+    }
+    catch {
+        throw new Error('Package "sharp" tidak terpasang. Jalankan: npm install sharp');
+    }
+};
+
+const loadFfmpeg = async () => {
+    try {
+        return (await import('fluent-ffmpeg')).default;
+    }
+    catch {
+        throw new Error('Package "fluent-ffmpeg" tidak terpasang. Jalankan: npm install fluent-ffmpeg');
+    }
+};
+
+const bufferToStream = (buffer) => {
+    const stream = new Readable({ read() { } });
+    stream.push(buffer);
+    stream.push(null);
+    return stream;
+};
+
+const ffmpegToBuffer = (ffmpeg, input, outputOptions, extraArgs = []) => new Promise((resolve, reject) => {
+    const output = new PassThrough();
+    const chunks = [];
+    output.on('data', (chunk) => chunks.push(chunk));
+    output.on('end', () => resolve(Buffer.concat(chunks)));
+    output.on('error', reject);
+    ffmpeg(bufferToStream(input))
+        .outputOptions([...outputOptions, ...extraArgs])
+        .on('error', (err) => reject(new Error(`ffmpeg error: ${err.message}`)))
+        .pipe(output, { end: true });
+});
+
+/** Resize/kompres gambar via sharp. fit: 'cover' | 'contain' | 'inside' ... */
+export const resizeImage = async (buffer, { width = 300, height = 300, fit = 'cover', format = 'jpeg', quality } = {}) => {
+    const sharp = await loadSharp();
+    let pipeline = sharp(buffer).resize(width, height, { fit, position: 'center', background: { r: 0, g: 0, b: 0, alpha: 0 } });
+    if (format === 'png') {
+        pipeline = pipeline.png();
+    }
+    else if (format === 'webp') {
+        pipeline = pipeline.webp(quality ? { quality } : {});
+    }
+    else {
+        pipeline = pipeline.jpeg(quality ? { quality } : {});
+    }
+    return pipeline.toBuffer();
+};
+
+/** Konversi video ke format kompatibel WhatsApp (MP4/H.264 + AAC). */
+export const convertToWhatsAppVideo = async (buffer, { maxWidth = 1280, videoBitrate = '1000k', audioBitrate = '128k' } = {}) => {
+    const ffmpeg = await loadFfmpeg();
+    return ffmpegToBuffer(ffmpeg, buffer, [
+        '-c:v libx264',
+        '-preset fast',
+        '-profile:v baseline',
+        '-level 3.0',
+        `-vf scale='min(${maxWidth},iw)':-2`,
+        `-b:v ${videoBitrate}`,
+        '-c:a aac',
+        `-b:a ${audioBitrate}`,
+        '-movflags +faststart',
+        '-f mp4'
+    ]);
+};
+
+/** Konversi audio apapun ke OGG/Opus (format voice note WhatsApp). */
+export const convertToOpusAudio = async (buffer, { bitrate = '32k', channels = 1, sampleRate = 48000 } = {}) => {
+    const ffmpeg = await loadFfmpeg();
+    return ffmpegToBuffer(ffmpeg, buffer, [
+        '-c:a libopus',
+        `-b:a ${bitrate}`,
+        `-ac ${channels}`,
+        `-ar ${sampleRate}`,
+        '-application voip',
+        '-f ogg'
+    ]);
+};
+
+/** Ambil satu frame video sebagai thumbnail JPEG. */
+export const getVideoThumbnail = async (buffer, timeSec = 0, { width = 300, height = 300 } = {}) => {
+    const ffmpeg = await loadFfmpeg();
+    const frame = await ffmpegToBuffer(ffmpeg, buffer, [
+        `-ss ${timeSec}`,
+        '-vframes 1',
+        '-vcodec png',
+        '-f image2pipe'
+    ]);
+    return resizeImage(frame, { width, height, format: 'jpeg' });
+};
+
+/** Metadata media (durasi, dimensi, format) via music-metadata (audio) atau ffprobe fallback. */
+export const probeMedia = async (buffer, mimeType = '') => {
+    try {
+        const { parseBuffer } = await import('music-metadata');
+        const meta = await parseBuffer(buffer, { mimeType: mimeType || undefined }, { duration: true });
+        return {
+            duration: meta.format.duration,
+            bitrate: meta.format.bitrate,
+            container: meta.format.container,
+            codec: meta.format.codec
+        };
+    }
+    catch (error) {
+        throw new Error(`probeMedia gagal: ${error.message}`);
+    }
+};
+
+/** Durasi MP4 tanpa ffmpeg — parse atom moov/mvhd langsung. */
+export const getMp4Duration = (buffer, { silent = true } = {}) => {
+    try {
+        if (!Buffer.isBuffer(buffer) || buffer.length < 8) {
+            if (silent) return 0;
+            throw new Error('Invalid buffer');
+        }
+        let offset = 0;
+        while (offset < buffer.length - 8) {
+            const size = buffer.readUInt32BE(offset);
+            if (size < 8 || offset + size > buffer.length) {
+                if (silent) return 0;
+                throw new Error('Invalid atom size');
+            }
+            const type = buffer.toString('ascii', offset + 4, offset + 8);
+            if (type === 'moov') {
+                let moovOffset = offset + 8;
+                const moovEnd = offset + size;
+                while (moovOffset < moovEnd - 8) {
+                    const childSize = buffer.readUInt32BE(moovOffset);
+                    if (childSize < 8 || moovOffset + childSize > moovEnd) {
+                        if (silent) return 0;
+                        throw new Error('Invalid child atom size');
+                    }
+                    const childType = buffer.toString('ascii', moovOffset + 4, moovOffset + 8);
+                    if (childType === 'mvhd') {
+                        const version = buffer.readUInt8(moovOffset + 8);
+                        if (version === 0) {
+                            const timescale = buffer.readUInt32BE(moovOffset + 20);
+                            const duration = buffer.readUInt32BE(moovOffset + 24);
+                            return timescale ? duration / timescale : 0;
+                        }
+                        if (version === 1) {
+                            const timescale = buffer.readUInt32BE(moovOffset + 32);
+                            const duration = Number(buffer.readBigUInt64BE(moovOffset + 36));
+                            return timescale ? duration / timescale : 0;
+                        }
+                    }
+                    moovOffset += childSize;
+                }
+            }
+            offset += size;
+        }
+        if (silent) return 0;
+        throw new Error('No mvhd found!');
+    }
+    catch (err) {
+        if (silent) return 0;
+        throw err;
+    }
+};

package/lib/Utils/media-set.d.ts

@@ -0,0 +1,6 @@
+export function updateProfilePictureFull(jid: any, content: any, sock: any): Promise<any>;
+export function updateProfilePictureFull2(jid: any, content: any, sock: any): Promise<any>;
+export function groupStatus(jid: any, content: any, sock: any): Promise<import("../index.js").proto.WebMessageInfo>;
+export function groupStatusV2(jids: any, content: any, sock: any): Promise<import("../index.js").proto.WebMessageInfo[]>;
+export function groupSetMemberLabel(jid: any, memberLabel: any, sock: any): Promise<any>;
+export function groupLabel(jid: any, text: any, sock: any): Promise<void>;

package/lib/Utils/media-set.js

@@ -0,0 +1,169 @@
+/**
+ * ported from Bail-master addons/media-set.ts.
+ * Profile-picture setters (full/panoramic variants) and group-status /
+ * member-label senders. Depends on this fork's own media-messages.js
+ * (also ported this batch) and its existing generateWAMessageContent /
+ * generateWAMessageFromContent / unixTimestampSeconds / S_WHATSAPP_NET.
+ *
+ * NOTE ON DUPLICATE-LOOKING SETTERS: `updateProfilePictureFull` and
+ * `updateProfilePictureFull2` are genuinely different, not duplicates —
+ * the first sends the `img` buffer from `generateProfilePictureFP`
+ * (scaled-to-fit 720x720 main image), the second sends the `preview`
+ * buffer from `generatePP` (normalized preview). Both are kept.
+ */
+import { randomBytes } from 'node:crypto';
+import { generateWAMessageContent, generateWAMessageFromContent } from './messages.js';
+import { unixTimestampSeconds } from './generics.js';
+import { S_WHATSAPP_NET } from '../WABinary/index.js';
+import { generatePP, generateProfilePictureFP } from './media-messages.js';
+/** Update the profile picture for yourself or a group — sends the main (scaled-to-fit) image. */
+export const updateProfilePictureFull = async (jid, content, sock) => {
+    const { query } = sock;
+    const { img } = await generateProfilePictureFP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: img
+            }
+        ]
+    });
+    return media;
+};
+/** Update the profile picture for yourself or a group — sends the normalized preview image. */
+export const updateProfilePictureFull2 = async (jid, content, sock) => {
+    const { query } = sock;
+    const { preview } = await generatePP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: preview
+            }
+        ]
+    });
+    return media;
+};
+/** Send a group status (status update visible only within a group's members). */
+export const groupStatus = async (jid, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const userJid = sock.authState?.creds?.me?.id;
+    const userJidLid = sock.authState?.creds?.me?.lid;
+    const m = generateWAMessageFromContent(jid, {
+        messageContextInfo: { messageSecret },
+        groupStatusMessageV2: {
+            message: {
+                ...inside,
+                messageContextInfo: { messageSecret }
+            }
+        }
+    }, { userJid, userJidLid });
+    await sock.relayMessage(jid, m.message, { messageId: m.key.id });
+    return m;
+};
+/** Send the same group status to multiple groups at once. */
+export const groupStatusV2 = async (jids, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const userJid = sock.authState?.creds?.me?.id;
+    const userJidLid = sock.authState?.creds?.me?.lid;
+    const results = [];
+    for (const id of jids) {
+        const m = generateWAMessageFromContent(id, {
+            messageContextInfo: { messageSecret },
+            groupStatusMessageV2: {
+                message: {
+                    ...inside,
+                    messageContextInfo: { messageSecret }
+                }
+            }
+        }, { userJid, userJidLid });
+        await sock.relayMessage(id, m.message, { messageId: m.key.id });
+        results.push(m);
+    }
+    return results;
+};
+/**
+ * Set/update a member's label in a group (awaits the relay and returns the result).
+ * Label is truncated to 30 characters (WA's limit).
+ */
+export const groupSetMemberLabel = async (jid, memberLabel, sock) => {
+    const result = await sock.relayMessage(jid, {
+        protocolMessage: {
+            type: 30,
+            memberLabel: {
+                label: memberLabel.slice(0, 30),
+                labelTimestamp: unixTimestampSeconds() || Date.now()
+            }
+        }
+    }, {
+        additionalNodes: [
+            {
+                tag: 'meta',
+                attrs: {
+                    tag_reason: 'user_update',
+                    appdata: 'member_tag'
+                },
+                content: undefined
+            }
+        ]
+    });
+    return result;
+};
+/**
+ * Set/update a member's label in a group — fire-and-forget variant (errors
+ * are swallowed, matching the source's behavior; prefer
+ * `groupSetMemberLabel` if you need to await/observe failures).
+ */
+export const groupLabel = async (jid, text, sock) => {
+    try {
+        void sock.relayMessage(jid, {
+            protocolMessage: {
+                type: 30,
+                memberLabel: {
+                    label: text.slice(0, 30),
+                    labelTimestamp: unixTimestampSeconds() || Date.now()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    }
+    catch {
+        // intentionally swallowed — matches source behavior
+    }
+};

package/lib/Utils/message-kind.d.ts

@@ -0,0 +1,26 @@
+export function resolveButtonAddonKind(message: any): WaButtonAddonKind | null;
+export function parseInteractiveReply(message: any): NormalizedInteractiveReply;
+/**
+ * Companion "addon kind" for list / native-flow style messages.
+ * Ported from zapo-js's resolveButtonAddonKind (src/message/encode/content.ts).
+ */
+export type WaButtonAddonKind = "list" | "interactive" | "payment_info" | "order_details";
+/**
+ * Normalized shape returned by parseInteractiveReply, regardless of which
+ * underlying WhatsApp reply type produced it.
+ */
+export type NormalizedInteractiveReply = {
+    kind: "buttons_response" | "list_response" | "native_flow_response" | "template_button_reply" | null;
+    /**
+     * - the button/row/native-flow id the user selected
+     */
+    id: string | null;
+    /**
+     * - visible text of the selection, if present
+     */
+    displayText: string | null;
+    /**
+     * - parsed paramsJson for native-flow responses, or null
+     */
+    params: any | null;
+};

package/lib/Utils/message-kind.js

@@ -0,0 +1,138 @@
+/**
+ * Evernight AI — lib/Utils/message-kind.js / Creator : Vanzxy🍃
+ *
+ * Addon-kind resolution logic adapted from zapo-js (MIT, © vinikjkkj)
+ * <https://github.com/vinikjkkj/zapo>, ported to this Baileys fork's
+ * message-content shape. The normalized reply parser below is original,
+ * written to cover this fork's own buttonsResponseMessage /
+ * listResponseMessage / interactiveResponseMessage / templateButtonReplyMessage
+ * send-side shapes (see messages.js).
+ */
+
+/**
+ * Unwraps ephemeral/viewOnce/edited wrappers to get at the real content.
+ * Mirrors the wrapper set already handled by normalizeMessageContent()
+ * in messages.js, kept local here to avoid a circular import.
+ */
+const unwrapMessage = (message) => {
+    let content = message;
+    for (let i = 0; i < 5; i++) {
+        const inner = content?.ephemeralMessage?.message ||
+            content?.viewOnceMessage?.message ||
+            content?.viewOnceMessageV2?.message ||
+            content?.viewOnceMessageV2Extension?.message ||
+            content?.documentWithCaptionMessage?.message ||
+            content?.editedMessage?.message;
+        if (!inner) {
+            break;
+        }
+        content = inner;
+    }
+    return content;
+};
+
+/**
+ * Companion "addon kind" for list / native-flow style messages.
+ * Ported from zapo-js's resolveButtonAddonKind (src/message/encode/content.ts).
+ * @typedef {'list' | 'interactive' | 'payment_info' | 'order_details'} WaButtonAddonKind
+ */
+
+const resolveNativeFlowAddonKind = (nativeFlow) => {
+    const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+    if (firstButtonName === 'payment_info')
+        return 'payment_info';
+    if (firstButtonName === 'review_and_pay')
+        return 'order_details';
+    return 'interactive';
+};
+
+/**
+ * Resolves which kind of button/list addon an outgoing message carries.
+ * Returns null if the message has no button/list/native-flow content.
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {WaButtonAddonKind | null}
+ */
+export const resolveButtonAddonKind = (message) => {
+    const msg = unwrapMessage(message);
+    if (!msg)
+        return null;
+    if (msg.listMessage)
+        return 'list';
+    if (msg.buttonsMessage)
+        return 'interactive';
+    const nativeFlow = msg.interactiveMessage?.nativeFlowMessage;
+    if (nativeFlow)
+        return resolveNativeFlowAddonKind(nativeFlow);
+    return null;
+};
+
+/**
+ * Normalized shape returned by parseInteractiveReply, regardless of which
+ * underlying WhatsApp reply type produced it.
+ * @typedef {Object} NormalizedInteractiveReply
+ * @property {'buttons_response'|'list_response'|'native_flow_response'|'template_button_reply'|null} kind
+ * @property {string|null} id - the button/row/native-flow id the user selected
+ * @property {string|null} displayText - visible text of the selection, if present
+ * @property {Object|null} params - parsed paramsJson for native-flow responses, or null
+ */
+
+/**
+ * Reads whatever a user tapped (button, list row, or native-flow reply) and
+ * returns one consistent shape, so plugin authors don't need a different
+ * branch per response type. Safe against malformed paramsJson (returns null
+ * instead of throwing).
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {NormalizedInteractiveReply}
+ */
+export const parseInteractiveReply = (message) => {
+    const msg = unwrapMessage(message);
+    const empty = { kind: null, id: null, displayText: null, params: null };
+    if (!msg)
+        return empty;
+    if (msg.buttonsResponseMessage) {
+        const r = msg.buttonsResponseMessage;
+        return {
+            kind: 'buttons_response',
+            id: r.selectedButtonId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    if (msg.listResponseMessage) {
+        const r = msg.listResponseMessage;
+        return {
+            kind: 'list_response',
+            id: r.singleSelectReply?.selectedRowId || null,
+            displayText: r.title || r.description || null,
+            params: null
+        };
+    }
+    if (msg.interactiveResponseMessage) {
+        const r = msg.interactiveResponseMessage;
+        let params = null;
+        if (r.nativeFlowResponseMessage?.paramsJson) {
+            try {
+                params = JSON.parse(r.nativeFlowResponseMessage.paramsJson);
+            }
+            catch {
+                params = null;
+            }
+        }
+        return {
+            kind: 'native_flow_response',
+            id: params?.id ?? r.nativeFlowResponseMessage?.name ?? null,
+            displayText: r.body?.text || null,
+            params
+        };
+    }
+    if (msg.templateButtonReplyMessage) {
+        const r = msg.templateButtonReplyMessage;
+        return {
+            kind: 'template_button_reply',
+            id: r.selectedId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    return empty;
+};