@itsliaaa/baileys 0.1.29 → 0.1.31

package/lib/Utils/messages.js

@@ -12,6 +12,7 @@ import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './gener
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
 import { prepareRichResponseMessage } from './rich-message-utils.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
+const CONCURRENCY_LIMIT = 10;
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -82,31 +83,24 @@ const assertColor = async (color) => {
         return assertedColor;
     }
 };
+// Lia@Changes 21-04-26 --- Refactor prepareWAMessageMedia function
 export const prepareWAMessageMedia = async (message, options) => {
     const logger = options.logger;
-    let mediaType;
-    for (const key of MEDIA_KEYS) {
-        if (key in message) {
-            mediaType = key;
-        }
-    }
+    const mediaType = MEDIA_KEYS.find(key => key in message);
     if (!mediaType) {
         throw new Boom('Invalid media type', { statusCode: 400 });
     }
-    const uploadData = {
-        ...message,
-        media: message[mediaType]
-    };
+    const uploadData = { ...message };
+    const mediaPayload = uploadData[mediaType];
+    delete uploadData[mediaType]; 
     if (uploadData.image || uploadData.video) {
         uploadData.annotations = mediaAnnotation;
     }
-    delete uploadData[mediaType];
-    // check if cacheable + generate cache key
-    const cacheableKey = typeof uploadData.media === 'object' &&
-        'url' in uploadData.media &&
-        !!uploadData.media.url &&
+    const cacheableKey = typeof mediaPayload === 'object' &&
+        'url' in mediaPayload &&
+        !!mediaPayload.url &&
         !!options.mediaCache &&
-        mediaType + ':' + uploadData.media.url;
+        `${mediaType}:${mediaPayload.url}`;
     if (mediaType === 'document' && !uploadData.fileName) {
         uploadData.fileName = LIBRARY_NAME;
     }
@@ -119,7 +113,7 @@ export const prepareWAMessageMedia = async (message, options) => {
             logger?.debug({ cacheableKey }, 'got media cache hit');
             const obj = proto.Message.decode(mediaBuff);
             const key = `${mediaType}Message`;
-            Object.assign(obj[key], { ...uploadData, media: undefined });
+            Object.assign(obj[key], uploadData); 
             return obj;
         }
     }
@@ -129,142 +123,118 @@ export const prepareWAMessageMedia = async (message, options) => {
     const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
+    let mediaUrl,
+        directPath,
+        thumbnailDirectPath,
+        thumbnailSha256,
+        fileSha256,
+        fileLength,
+        mediaKey,
+        fileEncSha256;
     // Lia@Changes 06-02-26 --- Add few support for sending media to newsletter (⁠≧⁠▽⁠≦⁠)
     if (isNewsletter) {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
-        const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
+        const rawData = await getRawMediaUploadData(mediaPayload, options.mediaTypeOverride || mediaType, logger);
+        fileSha256 = rawData.fileSha256;
+        fileLength = rawData.fileLength;
+        const filePath = rawData.filePath;
         const fileSha256B64 = fileSha256.toString('base64');
-        const [{ mediaUrl, directPath, thumbnailDirectPath, thumbnailSha256 }] = await Promise.all([
-            (async () => {
-                const result = options.upload(filePath, {
-                    fileEncSha256B64: fileSha256B64,
-                    mediaType,
-                    timeoutMs: options.mediaUploadTimeoutMs,
-                    newsletter: isNewsletter
-                });
-                logger?.debug({ mediaType, cacheableKey }, 'uploaded media');
-                return result;
-            })(),
+        const [uploadResult] = await Promise.all([
+            options.upload(filePath, {
+                fileEncSha256B64: fileSha256B64,
+                mediaType,
+                timeoutMs: options.mediaUploadTimeoutMs,
+                newsletter: true
+            }),
             (async () => {
                 try {
                     if (requiresThumbnailComputation) {
                         const { thumbnail } = await generateThumbnail(filePath, mediaType, options);
                         uploadData.jpegThumbnail = thumbnail;
-                        logger?.debug('generated thumbnail');
                     }
                     if (requiresDurationComputation) {
                         uploadData.seconds = await getAudioDuration(filePath);
-                        logger?.debug('computed audio duration');
                     }
                 }
                 catch (error) {
                     logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
                 }
             })()
-        ]).finally(async () => {
-            try {
-                await fs.unlink(filePath);
-                logger?.debug('removed tmp files');
-            }
-            catch (error) {
-                logger?.warn('failed to remove tmp file');
-            }
-        });
-        delete uploadData.media;
-        const obj = proto.Message.create({
-            // todo: add more support here
-            [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
-                url: mediaUrl,
-                directPath,
-                fileSha256,
-                fileLength,
-                thumbnailDirectPath,
-                thumbnailSha256,
-                ...uploadData
-            })
-        });
-        if (uploadData.ptv) {
-            obj.ptvMessage = obj.videoMessage;
-            delete obj.videoMessage;
-        }
-        if (obj.stickerMessage) {
-            obj.stickerMessage.stickerSentTs = Date.now();
-        }
-        if (cacheableKey) {
-            logger?.debug({ cacheableKey }, 'set cache');
-            await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
-        }
-        return obj;
+        ]);
+        // todo: add more support here
+        mediaUrl = uploadResult.mediaUrl;
+        directPath = uploadResult.directPath;
+        thumbnailDirectPath = uploadResult.thumbnailDirectPath;
+        thumbnailSha256 = uploadResult.thumbnailSha256;
+        fs.unlink(filePath).catch(() => logger?.warn('failed to remove tmp file'));
     }
-    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
-        logger,
-        saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
-        opts: options.options
-    });
-    const fileEncSha256B64 = fileEncSha256.toString('base64');
-    const [{ mediaUrl, directPath }] = await Promise.all([
-        (async () => {
-            const result = await options.upload(encFilePath, {
+    else {
+        const encryptedData = await encryptedStream(mediaPayload, options.mediaTypeOverride || mediaType, {
+            logger,
+            saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
+            opts: options.options
+        });
+        mediaKey = encryptedData.mediaKey;
+        fileEncSha256 = encryptedData.fileEncSha256;
+        fileSha256 = encryptedData.fileSha256;
+        fileLength = encryptedData.fileLength;
+        const encFilePath = encryptedData.encFilePath;
+        const originalFilePath = encryptedData.originalFilePath;
+        const fileEncSha256B64 = fileEncSha256.toString('base64');
+        const [uploadResult] = await Promise.all([
+            options.upload(encFilePath, {
                 fileEncSha256B64,
                 mediaType,
                 timeoutMs: options.mediaUploadTimeoutMs
-            });
-            logger?.debug({ mediaType, cacheableKey }, 'uploaded media');
-            return result;
-        })(),
-        (async () => {
-            try {
-                if (requiresThumbnailComputation) {
-                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
-                    uploadData.jpegThumbnail = thumbnail;
-                    if (!uploadData.width && originalImageDimensions) {
-                        uploadData.width = originalImageDimensions.width;
-                        uploadData.height = originalImageDimensions.height;
-                        logger?.debug('set dimensions');
+            }),
+            (async () => {
+                try {
+                    if (requiresThumbnailComputation) {
+                        const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
+                        uploadData.jpegThumbnail = thumbnail;
+                        if (!uploadData.width && originalImageDimensions) {
+                            uploadData.width = originalImageDimensions.width;
+                            uploadData.height = originalImageDimensions.height;
+                        }
+                    }
+                    if (requiresDurationComputation) {
+                        uploadData.seconds = await getAudioDuration(originalFilePath);
+                    }
+                    if (requiresWaveformProcessing) {
+                        uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
+                    }
+                    if (requiresAudioBackground) {
+                        uploadData.backgroundArgb = await assertColor(options.backgroundColor);
                     }
-                    logger?.debug('generated thumbnail');
-                }
-                if (requiresDurationComputation) {
-                    uploadData.seconds = await getAudioDuration(originalFilePath);
-                    logger?.debug('computed audio duration');
-                }
-                if (requiresWaveformProcessing) {
-                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
-                    logger?.debug('processed waveform');
                 }
-                if (requiresAudioBackground) {
-                    uploadData.backgroundArgb = await assertColor(options.backgroundColor);
-                    logger?.debug('computed backgroundColor audio status');
+                catch (error) {
+                    logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
                 }
-            }
-            catch (error) {
-                logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
-            }
-        })()
-    ]).finally(async () => {
-        try {
-            await fs.unlink(encFilePath);
-            if (originalFilePath) {
-                await fs.unlink(originalFilePath);
-            }
-            logger?.debug('removed tmp files');
-        }
-        catch (error) {
-            logger?.warn('failed to remove tmp file');
-        }
-    });
-    delete uploadData.media;
+            })()
+        ]);
+        mediaUrl = uploadResult.mediaUrl;
+        directPath = uploadResult.directPath;
+        fs.unlink(encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+        fs.unlink(originalFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+    }
+    const messagePayload = {
+        url: mediaUrl,
+        directPath,
+        fileSha256,
+        fileLength,
+        ...uploadData
+    };
+    if (isNewsletter) {
+        messagePayload.thumbnailDirectPath = thumbnailDirectPath;
+        messagePayload.thumbnailSha256 = thumbnailSha256;
+    }
+    else {
+        messagePayload.mediaKey = mediaKey;
+        messagePayload.fileEncSha256 = fileEncSha256;
+        messagePayload.mediaKeyTimestamp = unixTimestampSeconds();
+    }
     const obj = proto.Message.create({
-        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
-            url: mediaUrl,
-            directPath,
-            mediaKey,
-            fileEncSha256,
-            fileSha256,
-            fileLength,
-            mediaKeyTimestamp: unixTimestampSeconds(),
-            ...uploadData
-        })
+        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject(messagePayload)
     });
     if (uploadData.ptv) {
         obj.ptvMessage = obj.videoMessage;
@@ -274,8 +244,8 @@ export const prepareWAMessageMedia = async (message, options) => {
         obj.stickerMessage.stickerSentTs = Date.now();
     }
     if (cacheableKey) {
-        logger?.debug({ cacheableKey }, 'set cache');
-        await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+        logger?.debug({ cacheableKey }, 'set cache (background)');
+        options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
     }
     return obj;
 };
@@ -319,6 +289,7 @@ const prepareProductMessage = async (message, options) => {
  * Credits: Work on ensuring stickerPackMessage fields are valid by @jlucaso1 (https://github.com/jlucaso1).
  * based on https://github.com/WhiskeySockets/Baileys/pull/1561
  */
+// Lia@Changes 21-04-26 --- Enhanced prepareStickerPackMessage
 const prepareStickerPackMessage = async (message, options) => {
     const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys' } = message;
     if (stickers.length > 60) {
@@ -330,136 +301,124 @@ const prepareStickerPackMessage = async (message, options) => {
     if (!cover) {
         throw new Boom('Sticker pack must contain a cover', { statusCode: 400 });
     }
-    // Lia@Changes 01-02-26 --- Add caching for sticker pack (similiar to prepareWAMessageMedia)
-    const cacheableKey = Array.isArray(stickers) &&
-        stickers.length &&
-        !!options.mediaCache &&
-        'sticker:' + stickers
-            .reduce((acc, x) => {
-                const url = typeof x.data === 'object' &&
-                    'url' in x.data &&
-                    !!x.data.url &&
-                    x.data.url;
-                if (url) acc.push(url);
-                return acc;
-            }, [])
-            .join('@');
+    const logger = options.logger;
+    // Lia@Changes 01-02-26 --- Add caching for sticker pack
+    let cacheableKey = false;
+    if (Array.isArray(stickers) && stickers.length && options.mediaCache) {
+        const urls = [];
+        for (let i = 0; i < stickers.length; i++) {
+            const data = stickers[i].data;
+            if (typeof data === 'object' && data?.url) {
+                urls.push(data.url);
+            }
+        }
+        if (urls.length > 0) {
+            cacheableKey = 'sticker:' + urls.join('@');
+        }
+    }
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
-            options.logger?.debug({ cacheableKey }, 'got media cache hit');
+            logger?.debug({ cacheableKey }, 'got media cache hit');
             return proto.Message.StickerPackMessage.decode(mediaBuff);
         }
     }
     const lib = await getImageProcessingLibrary();
+    const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+    const hasImage = 'image' in lib && !!lib.image?.Transformer;
+    const hasJimp = 'jimp' in lib && !!lib.jimp?.Jimp;
+    if (!hasSharp && !hasImage) {
+        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
+    }
     const stickerPackIdValue = generateMessageIDV2();
     const stickerData = {};
-    const stickerPromises = stickers.map(async (sticker, i) => {
-        const { stream } = await getStream(sticker.data);
-        const buffer = await toBuffer(stream);
-        let webpBuffer,
-            isAnimated = false;
-        const isWebP = isWebPBuffer(buffer);
-        if (isWebP) {
-            // Already WebP - preserve original to keep exif metadata and animation
-            webpBuffer = buffer;
-            isAnimated = isAnimatedWebP(buffer);
-        }
-        else if ('sharp' in lib && lib.sharp?.default) {
-            // Convert to WebP, preserving metadata
-            webpBuffer = await lib
-                .sharp
-                .default(buffer)
-                .resize(512, 512, { fit: 'inside' })
-                .webp({ quality: 80 })
-                .toBuffer();
-            // Non-WebP inputs converted to WebP are not animated
-            isAnimated = false;
-        }
-        else if ('image' in lib && lib.image?.Transformer) {
-            webpBuffer = await new lib
-                .image
-                .Transformer(buffer)
-                .resize(512, 512)
-                .webp(80);
-            // Non-WebP inputs converted to WebP are not animated
-            isAnimated = false;
+    const stickerMetadata = new Array(stickers.length);
+    for (let i = 0; i < stickers.length; i += CONCURRENCY_LIMIT) {
+        const promises = [];
+        const chunkEnd = Math.min(i + CONCURRENCY_LIMIT, stickers.length);
+        for (let j = i; j < chunkEnd; j++) {
+            promises.push((async (index) => {
+                const sticker = stickers[index];
+                const { stream } = await getStream(sticker.data);
+                const buffer = await toBuffer(stream);
+                let webpBuffer;
+                let isAnimated = false;
+                if (isWebPBuffer(buffer)) {
+                    webpBuffer = buffer;
+                    isAnimated = isAnimatedWebP(buffer);
+                }
+                else if (hasSharp) {
+                    webpBuffer = await lib.sharp.default(buffer)
+                        .resize(512, 512, { fit: 'inside' })
+                        .webp({ quality: 80 })
+                        .toBuffer();
+                }
+                else {
+                    webpBuffer = await new lib.image.Transformer(buffer)
+                        .resize(512, 512)
+                        .webp(80);
+                }
+                if (webpBuffer.length > 1024 * 1024) {
+                   throw new Boom(`Sticker at index ${index} exceeds the 1MB size limit`, { statusCode: 400 });
+                }
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+                const fileName = `${hash}.webp`;
+                stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
+                stickerMetadata[index] = {
+                    fileName,
+                    mimetype: 'image/webp',
+                    isAnimated,
+                    emojis: sticker.emojis || ['✨'],
+                    accessibilityLabel: sticker.accessibilityLabel || '‎'
+                };
+            })(j));
         }
-        else {
-            throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP. Either install sharp or @napi-rs/image or provide stickers in WebP format.');
-        }
-        if (webpBuffer.length > 1024 * 1024) {
-           throw new Boom(`Sticker at index ${i} exceeds the 1MB size limit`, { statusCode: 400 });
-        }
-        const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
-        const fileName = hash + '.webp';
-        stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
-        return {
-            fileName,
-            mimetype: 'image/webp',
-            isAnimated,
-            emojis: sticker.emojis || ['✨'],
-            accessibilityLabel: sticker.accessibilityLabel || '‎'
-        };
-    });
-    const stickerMetadata = await Promise.all(stickerPromises);
-    // Process and add cover/tray icon to the ZIP
-    const trayIconFileName = stickerPackIdValue + '.webp';
+        await Promise.all(promises);
+    }
+    const trayIconFileName = `${stickerPackIdValue}.webp`;
     const { stream: coverStream } = await getStream(cover);
     const coverBuffer = await toBuffer(coverStream);
     let coverWebpBuffer;
-    const isCoverWebP = isWebPBuffer(coverBuffer);
-    if (isCoverWebP) {
-        // Already WebP - preserve original to keep exif metadata
+    if (isWebPBuffer(coverBuffer)) {
         coverWebpBuffer = coverBuffer;
     }
-    else if ('sharp' in lib && lib.sharp?.default) {
-        coverWebpBuffer = await lib
-            .sharp
-            .default(coverBuffer)
+    else if (hasSharp) {
+        coverWebpBuffer = await lib.sharp.default(coverBuffer)
             .resize(512, 512, { fit: 'inside' })
             .webp({ quality: 80 })
             .toBuffer();
     }
-    else if ('image' in lib && lib.image?.Transformer) {
-        coverWebpBuffer = await new lib
-            .image
-            .Transformer(coverBuffer)
+    else {
+        coverWebpBuffer = await new lib.image.Transformer(coverBuffer)
             .resize(512, 512)
             .webp(80);
     }
-    else {
-        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting cover to WebP. Either install sharp or @napi-rs/image or provide cover in WebP format.');
-    }
-    // Add cover to ZIP data
     stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
     const zipBuffer = await new Promise((resolve, reject) => {
-        zip(stickerData, (error, data) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(Buffer.from(data));
-            }
-        });
+        zip(stickerData, (error, data) => error ? reject(error) : resolve(Buffer.from(data)));
     });
-    const stickerPackSize = zipBuffer.length;
     const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
-        logger: options.logger,
+        logger,
         opts: options.options
     });
-    const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
-        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
-        mediaType: 'sticker-pack',
-        timeoutMs: options.mediaUploadTimeoutMs
-    });
-    await fs.unlink(stickerPackUpload.encFilePath);
+    let stickerPackUploadResult;
+    try {
+        stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+    }
+    finally {
+        fs.unlink(stickerPackUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+    }
     const obj = {
-        name: name,
-        publisher: publisher,
+        name,
+        publisher,
         stickerPackId: stickerPackIdValue,
         packDescription: description,
         stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
-        stickerPackSize: stickerPackSize,
+        stickerPackSize: zipBuffer.length,
         stickers: stickerMetadata,
         fileSha256: stickerPackUpload.fileSha256,
         fileEncSha256: stickerPackUpload.fileEncSha256,
@@ -467,31 +426,19 @@ const prepareStickerPackMessage = async (message, options) => {
         directPath: stickerPackUploadResult.directPath,
         fileLength: stickerPackUpload.fileLength,
         mediaKeyTimestamp: unixTimestampSeconds(),
-        trayIconFileName: trayIconFileName
+        trayIconFileName
     };
     try {
-        // Reuse the cover buffer we already processed for thumbnail generation
         let thumbnailBuffer;
-        if ('sharp' in lib && lib.sharp?.default) {
-            thumbnailBuffer = await lib
-                .sharp
-                .default(coverBuffer)
-                .resize(252, 252)
-                .jpeg()
-                .toBuffer();
-        }
-        if ('image' in lib && lib.image?.Transformer) {
-            thumbnailBuffer = await new lib
-                .image
-                .Transformer(coverBuffer)
-                .resize(252, 252)
-                .jpeg();
-        }
-        else if ('jimp' in lib && lib.jimp?.Jimp) {
+        if (hasSharp) {
+            thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+        }
+        else if (hasImage) {
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
+        }
+        else if (hasJimp) {
             const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
-            thumbnailBuffer = await jimpImage
-                .resize({ w: 252, h: 252 })
-                .getBuffer('image/jpeg');
+            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
         }
         else {
             throw new Error('No image processing library available for thumbnail generation');
@@ -500,16 +447,21 @@ const prepareStickerPackMessage = async (message, options) => {
             throw new Error('Failed to generate thumbnail buffer');
         }
         const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
-            logger: options.logger,
+            logger,
             opts: options.options,
-            mediaKey: stickerPackUpload.mediaKey // Use same mediaKey as the sticker pack ZIP
-        });
-        const thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
-            fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
-            mediaType: 'thumbnail-sticker-pack',
-            timeoutMs: options.mediaUploadTimeoutMs
+            mediaKey: stickerPackUpload.mediaKey
         });
-        await fs.unlink(thumbUpload.encFilePath);
+        let thumbUploadResult;
+        try {
+            thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs
+            });
+        }
+        finally {
+            fs.unlink(thumbUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+        }
         Object.assign(obj, {
             thumbnailDirectPath: thumbUploadResult.directPath,
             thumbnailSha256: thumbUpload.fileSha256,
@@ -520,14 +472,13 @@ const prepareStickerPackMessage = async (message, options) => {
         });
     }
     catch (error) {
-        options.logger?.warn?.(`Thumbnail generation failed: ${error}`);
+        logger?.warn(`Thumbnail generation failed: ${error}`);
     }
-    const content = obj;
     if (cacheableKey) {
-        options.logger?.debug({ cacheableKey }, 'set cache');
-        await options.mediaCache.set(cacheableKey, WAProto.Message.StickerPackMessage.encode(content).finish());
+        logger?.debug({ cacheableKey }, 'set cache (background)');
+        options.mediaCache.set(cacheableKey, WAProto.Message.StickerPackMessage.encode(obj).finish());
     }
-    return WAProto.Message.StickerPackMessage.fromObject(content);
+    return WAProto.Message.StickerPackMessage.fromObject(obj);
 };
 // Lia@Changes 30-01-26 --- Add native flow button helper for interactive message
 const prepareNativeFlowButtons = (message) => {
@@ -1319,6 +1270,12 @@ export const generateWAMessageContent = async (message, options) => {
         }
         m = { invoiceMessage };
     }
+    if (shouldIncludeReportingToken(m)) {
+        m.messageContextInfo = m.messageContextInfo || {};
+        if (!m.messageContextInfo.messageSecret) {
+            m.messageContextInfo.messageSecret = randomBytes(32);
+        }
+    }
     // Lia@Changes 31-01-26 --- Add direct externalAdReply access (no need to create contextInfo first)
     if (hasOptionalProperty(message, 'externalAdReply') && !!message.externalAdReply) {
         const messageType = Object.keys(m)[0];
@@ -1336,9 +1293,9 @@ export const generateWAMessageContent = async (message, options) => {
             mediaType: content.mediaType || 1,
             mediaUrl: content.url,
             renderLargerThumbnail: content.largeThumbnail,
-            sourceUrl: content.url + '?update=' + Date.now(),
+            sourceUrl: content.url,
             thumbnail: content.thumbnail,
-            thumbnailUrl: content.url,
+            thumbnailUrl: content.url + '?update=' + Date.now(),
             title: content.title || LIBRARY_NAME
         };
         delete externalAdReply.subTitle;
@@ -1434,12 +1391,6 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
-    if (shouldIncludeReportingToken(m)) {
-        m.messageContextInfo = m.messageContextInfo || {};
-        if (!m.messageContextInfo.messageSecret) {
-            m.messageContextInfo.messageSecret = randomBytes(32);
-        }
-    }
     return proto.Message.create(m);
 };
 export const generateWAMessageFromContent = (jid, message, options) => {