@yrpri/api 9.0.90 → 9.0.92

package/active-citizen/engine/allOurIdeas/iconGenerator.js

@@ -1,51 +1,38 @@
-import fs from "fs";
 import path from "path";
+import fs from "fs";
 import { v4 as uuidv4 } from "uuid";
+import axios from "axios";
 import models from "../../../models/index.cjs";
-import { CollectionImageGenerator } from "../../llms/collectionImageGenerator.js";
+import { CollectionImageGenerator } from "../../llms/imageGeneration/collectionImageGenerator.js";
 const dbModels = models;
 const Image = dbModels.Image;
 export class AoiIconGenerator extends CollectionImageGenerator {
     async createCollectionImage(workPackage) {
-        return new Promise(async (resolve, reject) => {
-            let newImageUrl;
-            const imageFilePath = path.join("/tmp", `${uuidv4()}.png`);
-            const s3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}.png`;
-            try {
-                const imageUrl = await this.getImageUrlFromDalle(workPackage.prompt, workPackage.imageType);
-                if (imageUrl) {
-                    await this.downloadImage(imageUrl, imageFilePath);
-                    console.debug(fs.existsSync(imageFilePath)
-                        ? "File downloaded successfully."
-                        : "File download failed.");
-                    const resizedImageFilePath = await this.resizeImage(imageFilePath, 400, 400);
-                    await this.uploadImageToS3(process.env.S3_BUCKET, resizedImageFilePath, s3ImagePath);
-                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
-                        newImageUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3ImagePath}`;
-                    }
-                    else {
-                        newImageUrl = `https://${process.env
-                            .S3_BUCKET}.s3.amazonaws.com/${s3ImagePath}`;
-                    }
-                    const formats = JSON.stringify([newImageUrl]);
-                    const image = await Image.build({
-                        user_id: workPackage.userId,
-                        s3_bucket_name: process.env.S3_BUCKET,
-                        original_filename: "n/a",
-                        formats,
-                        user_agent: "AI worker",
-                        ip_address: "127.0.0.1",
-                    });
-                    await image.save();
-                    resolve({ imageId: image.id, imageUrl: newImageUrl });
-                }
-                else {
-                    reject("Error getting image URL from prompt.");
-                }
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
+        // 1. Generate the image and record using the base implementation.
+        const { imageId, imageUrl } = await super.createCollectionImage(workPackage);
+        // 2. Now process the image for the icon:
+        // Download the generated image to a temporary location.
+        const tempIconPath = path.join("/tmp", `${uuidv4()}-icon.png`);
+        await this.imageProcessorService.downloadImage(imageUrl, tempIconPath, axios);
+        if (!fs.existsSync(tempIconPath)) {
+            throw new Error("Failed to download the generated image for icon processing.");
+        }
+        // Resize the downloaded image to 400x400 pixels.
+        const resizedIconPath = await this.imageProcessorService.resizeImage(tempIconPath, 400, 400);
+        // Define a new S3 path for the icon image.
+        const iconS3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}-icon.png`;
+        // Upload the resized icon to S3.
+        await this.s3Service.uploadImageToS3(process.env.S3_BUCKET, resizedIconPath, iconS3ImagePath);
+        // Construct a public URL for the icon image.
+        const newIconUrl = process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN
+            ? `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${iconS3ImagePath}`
+            : `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${iconS3ImagePath}`;
+        // Optionally, update the DB record with the new icon URL.
+        const imageRecord = await Image.findOne({ where: { id: imageId } });
+        if (imageRecord) {
+            imageRecord.formats = JSON.stringify([newIconUrl]);
+            await imageRecord.save();
+        }
+        return { imageId, imageUrl: newIconUrl };
     }
 }

package/active-citizen/llms/baseChatBot.js

@@ -12,6 +12,9 @@ export class YpBaseChatBot {
     get redisKey() {
         return `${YpBaseChatBot.redisMemoryKeyPrefix}-${this.memoryId}`;
     }
+    destroy() {
+        this.wsClientSocket = undefined;
+    }
     static loadMemoryFromRedis(memoryId) {
         return new Promise(async (resolve, reject) => {
             try {
@@ -70,12 +73,14 @@ export class YpBaseChatBot {
         });
         this.wsClientId = wsClientId;
         this.wsClientSocket = wsClients.get(this.wsClientId);
+        this.wsClients = wsClients;
+        console.log(`WebSockets: BaseChatBot constructor for ${this.wsClientId}`);
+        if (!this.wsClientSocket) {
+            console.error(`WebSockets: WS Client ${this.wsClientId} not found in streamWebSocketResponses`);
+        }
         this.openaiClient = new OpenAI({
             apiKey: process.env.OPENAI_API_KEY,
         });
-        if (!this.wsClientSocket) {
-            console.error(`WS Client ${this.wsClientId} not found in streamWebSocketResponses`);
-        }
         this.memoryId = memoryId;
         this.setupMemory(memoryId);
     }
@@ -163,7 +168,7 @@ export class YpBaseChatBot {
     }
     sendToClient(sender, message, type = "stream", uniqueToken = undefined, hiddenContextMessage = false) {
         try {
-            if (DEBUG) {
+            if (process.env.WS_DEBUG) {
                 console.log(`sendToClient: ${JSON.stringify({ sender, type, message, hiddenContextMessage }, null, 2)}`);
             }
             this.wsClientSocket.send(JSON.stringify({

package/active-citizen/llms/collectionImageGenerator.js

@@ -1,4 +1,4 @@
-import { OpenAI } from "openai";
+import { AzureOpenAI, OpenAI } from "openai";
 import axios from "axios";
 import AWS from "aws-sdk";
 import fs from "fs";
@@ -7,7 +7,6 @@ import { v4 as uuidv4 } from "uuid";
 import models from "../../models/index.cjs";
 import sharp from "sharp";
 import Replicate from "replicate";
-import { OpenAIClient, AzureKeyCredential, } from "@azure/openai";
 const dbModels = models;
 const Image = dbModels.Image;
 const AcBackgroundJob = dbModels.AcBackgroundJob;
@@ -16,11 +15,47 @@ const disableFlux = false;
 export class CollectionImageGenerator {
     async resizeImage(imagePath, width, height) {
         const resizedImageFilePath = path.join("/tmp", `${uuidv4()}.png`);
-        await sharp(imagePath)
-            .resize({ width, height })
-            .toFile(resizedImageFilePath);
-        fs.unlinkSync(imagePath);
-        return resizedImageFilePath;
+        try {
+            // 1) Initialize Sharp instance
+            const image = sharp(imagePath).rotate(); // rotate fixes orientation from EXIF
+            // 2) Read metadata to validate format
+            const metadata = await image.metadata();
+            const validFormats = [
+                "jpeg",
+                "png",
+                "webp",
+                "gif",
+                "tiff",
+                "avif",
+                "svg"
+            ];
+            if (!metadata.format || !validFormats.includes(metadata.format)) {
+                throw new Error(`Unsupported format: ${metadata.format} (expected one of ${validFormats.join(", ")})`);
+            }
+            // 3) Resize + convert
+            await image
+                .resize({
+                width,
+                height,
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .toFormat("png", {
+                quality: 90,
+                progressive: true,
+            })
+                .toFile(resizedImageFilePath);
+            // 4) Remove the original file after successful resize
+            fs.unlinkSync(imagePath);
+            return resizedImageFilePath;
+        }
+        catch (err) {
+            console.error("Error resizing image:", err);
+            if (fs.existsSync(resizedImageFilePath)) {
+                fs.unlinkSync(resizedImageFilePath);
+            }
+            throw err;
+        }
     }
     async downloadImage(imageUrl, imageFilePath) {
         const response = await axios({
@@ -31,12 +66,11 @@ export class CollectionImageGenerator {
         const writer = fs.createWriteStream(imageFilePath);
         response.data.pipe(writer);
         return new Promise((resolve, reject) => {
-            writer.on("finish", resolve);
+            writer.on("finish", () => resolve());
             writer.on("error", reject);
         });
     }
     async deleteS3Url(imageUrl) {
-        // Parse the S3 bucket and key from the URL
         const { bucket, key } = this.parseImageUrl(imageUrl);
         if (!bucket || !key) {
             throw new Error("Could not parse bucket or key from URL");
@@ -45,9 +79,9 @@ export class CollectionImageGenerator {
         const params = {
             Bucket: bucket,
             Key: key,
-            ACL: "private", // Changing the ACL to private
+            ACL: "private",
         };
-        console.log(`=========================____________________>>>>>>>>>>>>>>>>> Disabling/Deleting Key from S3: ${JSON.stringify(params)}`);
+        console.log(`Disabling/Deleting Key from S3: ${JSON.stringify(params)}`);
         return new Promise((resolve, reject) => {
             s3.putObjectAcl(params, (err, data) => {
                 if (err) {
@@ -55,14 +89,12 @@ export class CollectionImageGenerator {
                     reject(err);
                 }
                 else {
-                    console.log(`============= Deleted image from S3: ${imageUrl}`, data);
+                    console.log(`Deleted image from S3: ${imageUrl}`, data);
                     if (process.env.CLOUDFLARE_API_KEY &&
                         process.env.CLOUDFLARE_ZONE_ID) {
                         console.log("Purging Cloudflare cache for image:", imageUrl);
                         axios
-                            .post(`https://api.cloudflare.com/client/v4/zones/${process.env.CLOUDFLARE_ZONE_ID}/purge_cache`, {
-                            files: [imageUrl],
-                        }, {
+                            .post(`https://api.cloudflare.com/client/v4/zones/${process.env.CLOUDFLARE_ZONE_ID}/purge_cache`, { files: [imageUrl] }, {
                             headers: {
                                 Authorization: `Bearer ${process.env.CLOUDFLARE_API_KEY}`,
                                 "Content-Type": "application/json",
@@ -79,11 +111,9 @@ export class CollectionImageGenerator {
                                 console.error("Headers:", error.response.headers);
                             }
                             else if (error.request) {
-                                // The request was made but no response was received
                                 console.error("No response received:", error.request);
                             }
                             else {
-                                // Something happened in setting up the request that triggered an Error
                                 console.error("Error setting up request:", error.message);
                             }
                             resolve(data);
@@ -100,14 +130,12 @@ export class CollectionImageGenerator {
         let bucket, key;
         if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN &&
             imageUrl.includes(process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN)) {
-            // Parse URL for Cloudflare proxied images
-            const path = new URL(imageUrl).pathname;
-            const [, ...pathParts] = path.split("/");
+            const urlPath = new URL(imageUrl).pathname;
+            const [, ...pathParts] = urlPath.split("/");
             bucket = process.env.S3_BUCKET;
             key = pathParts.join("/");
         }
         else {
-            // Parse URL for direct S3 images
             const match = imageUrl.match(/https:\/\/(.+?)\.s3\.amazonaws\.com\/(.+)/);
             if (match) {
                 bucket = match[1];
@@ -129,7 +157,7 @@ export class CollectionImageGenerator {
             Bucket: bucket,
             Key: key,
             Body: fileContent,
-            ACL: "public-read", // Makes sure the uploaded files are publicly accessible
+            ACL: "public-read",
             ContentType: "image/png",
             ContentDisposition: "inline",
         };
@@ -138,8 +166,7 @@ export class CollectionImageGenerator {
                 if (err) {
                     reject(err);
                 }
-                fs.unlinkSync(filePath); // Deleting file from local storage
-                //console.log(`Upload response: ${JSON.stringify(data)}`);
+                fs.unlinkSync(filePath);
                 resolve(data);
             });
         });
@@ -194,7 +221,12 @@ export class CollectionImageGenerator {
         const azureOpenAiApiKey = process.env["AZURE_OPENAI_API_KEY"];
         let client;
         if (azureOpenAiApiKey && azureOpenaAiBase) {
-            client = new OpenAIClient(azureOpenaAiBase, new AzureKeyCredential(azureOpenAiApiKey));
+            client = new AzureOpenAI({
+                apiKey: azureOpenAiApiKey,
+                endpoint: azureOpenaAiBase,
+                deployment: process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME,
+                apiVersion: "2024-10-21",
+            });
         }
         else {
             client = new OpenAI({
@@ -202,7 +234,7 @@ export class CollectionImageGenerator {
             });
         }
         let retryCount = 0;
-        let retrying = true; // Initialize as true
+        let retrying = true;
         let result;
         let imageOptions;
         if (type === "logo") {
@@ -229,19 +261,24 @@ export class CollectionImageGenerator {
         while (retrying && retryCount < maxRetryCount) {
             try {
                 if (azureOpenAiApiKey && azureOpenaAiBase) {
-                    result = await client.getImages(process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME, prompt, imageOptions);
+                    result = await client.images.generate({
+                        prompt,
+                        n: imageOptions.n,
+                        size: imageOptions.size,
+                        quality: imageOptions.quality,
+                    });
                 }
                 else {
                     result = await client.images.generate({
                         model: "dall-e-3",
                         prompt,
                         n: imageOptions.n,
-                        quality: imageOptions.quality,
                         size: imageOptions.size,
+                        quality: imageOptions.quality,
                     });
                 }
                 if (result) {
-                    retrying = false; // Only change retrying to false if there is a result.
+                    retrying = false;
                 }
                 else {
                     console.debug(`Result: NONE`);
@@ -294,8 +331,7 @@ export class CollectionImageGenerator {
                         newImageUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3ImagePath}`;
                     }
                     else {
-                        newImageUrl = `https://${process.env
-                            .S3_BUCKET}.s3.amazonaws.com/${s3ImagePath}`;
+                        newImageUrl = `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${s3ImagePath}`;
                     }
                     const formats = JSON.stringify([newImageUrl]);
                     const image = await Image.build({

package/active-citizen/llms/imageGeneration/collectionImageGenerator.js

@@ -0,0 +1,103 @@
+import path from "path";
+import fs from "fs";
+import { v4 as uuidv4 } from "uuid";
+import axios from "axios";
+import { FluxImageGenerator } from "./fluxImageGenerator.js";
+import { DalleImageGenerator } from "./dalleImageGenerator.js";
+import { ImageProcessorService } from "./imageProcessorService.js";
+import { S3Service } from "./s3Service.js";
+// Suppose these come from your codebase
+import models from "../../../models/index.cjs";
+import { ImagenImageGenerator } from "./imagenImageGenerator.js";
+// For reference, in your code:
+const dbModels = models;
+const Image = dbModels.Image;
+const AcBackgroundJob = dbModels.AcBackgroundJob;
+const disableFlux = false;
+const useImagen = true;
+export class CollectionImageGenerator {
+    constructor() {
+        this.s3Service = new S3Service(process.env.CLOUDFLARE_API_KEY, process.env.CLOUDFLARE_ZONE_ID);
+        this.imageProcessorService = new ImageProcessorService();
+        // Initialize generators
+        if (!disableFlux &&
+            process.env.REPLICATE_API_TOKEN &&
+            process.env.FLUX_PRO_MODEL_NAME) {
+            this.fluxImageGenerator = new FluxImageGenerator(process.env.REPLICATE_API_TOKEN, process.env.FLUX_PRO_MODEL_NAME);
+        }
+        this.dalleImageGenerator = new DalleImageGenerator(process.env.AZURE_OPENAI_API_BASE, process.env.AZURE_OPENAI_API_KEY, process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME, process.env.OPENAI_API_KEY);
+        if (useImagen && process.env.GOOGLE_CLOUD_PROJECT_ID) {
+            this.imagenImageGenerator = new ImagenImageGenerator(this.s3Service);
+        }
+    }
+    /**
+     * Orchestrates image generation (via Flux or DALL·E), downloads that image,
+     * uploads it to S3, and saves a record in the DB.
+     */
+    async createCollectionImage(workPackage) {
+        return new Promise(async (resolve, reject) => {
+            let newImageUrl;
+            const imageFilePath = path.join("/tmp", `${uuidv4()}.png`);
+            const s3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}.png`;
+            try {
+                let imageGenerator;
+                // Decide which generator to use
+                if (this.imagenImageGenerator) {
+                    imageGenerator = this.imagenImageGenerator;
+                    console.info("Using ImagenImageGenerator");
+                }
+                else if (this.fluxImageGenerator) {
+                    imageGenerator = this.fluxImageGenerator;
+                    console.info("Using FluxImageGenerator");
+                }
+                else {
+                    imageGenerator = this.dalleImageGenerator;
+                    console.info("Using DalleImageGenerator");
+                }
+                // 1) Generate image
+                const imageUrl = await imageGenerator.generateImageUrl(workPackage.prompt, workPackage.imageType);
+                if (!imageUrl) {
+                    return reject("Error getting image URL from prompt.");
+                }
+                if (useImagen && this.imagenImageGenerator) {
+                    newImageUrl = imageUrl;
+                }
+                else {
+                    // 2) Download image to temporary location
+                    await this.imageProcessorService.downloadImage(imageUrl, imageFilePath, axios);
+                    console.debug(fs.existsSync(imageFilePath)
+                        ? "File downloaded successfully."
+                        : "File download failed.");
+                    // (Optional) If you want to resize the image before upload:
+                    // const resizedPath = await this.imageProcessorService.resizeImage(imageFilePath, 1024, 1024);
+                    // Upload the `resizedPath` instead of `imageFilePath`
+                    // 3) Upload image to S3
+                    await this.s3Service.uploadImageToS3(process.env.S3_BUCKET, imageFilePath, s3ImagePath);
+                    // 4) Construct a public URL (optionally going through Cloudflare)
+                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
+                        newImageUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3ImagePath}`;
+                    }
+                    else {
+                        newImageUrl = `https://${process.env
+                            .S3_BUCKET}.s3.amazonaws.com/${s3ImagePath}`;
+                    }
+                }
+                // 5) Save record in DB
+                const formats = JSON.stringify([newImageUrl]);
+                const imageRecord = await Image.build({
+                    user_id: workPackage.userId,
+                    s3_bucket_name: process.env.S3_BUCKET,
+                    original_filename: "n/a",
+                    formats,
+                    user_agent: "AI worker",
+                    ip_address: "127.0.0.1",
+                });
+                await imageRecord.save();
+                resolve({ imageId: imageRecord.id, imageUrl: newImageUrl });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}

package/active-citizen/llms/imageGeneration/dalleImageGenerator.js

@@ -0,0 +1,83 @@
+import { AzureOpenAI, OpenAI } from "openai";
+export class DalleImageGenerator {
+    constructor(azureOpenaAiBase, azureOpenAiApiKey, azureDalleDeployment, openAiKey) {
+        this.maxRetryCount = 3;
+        this.azureOpenaAiBase = azureOpenaAiBase;
+        this.azureOpenAiApiKey = azureOpenAiApiKey;
+        this.azureDalleDeployment = azureDalleDeployment;
+        this.openAiKey = openAiKey;
+    }
+    async generateImageUrl(prompt, type = "logo") {
+        let client;
+        let result;
+        let retryCount = 0;
+        let retrying = true;
+        // Decide which client to instantiate (Azure vs. standard OpenAI)
+        if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+            client = new AzureOpenAI({
+                apiKey: this.azureOpenAiApiKey,
+                endpoint: this.azureOpenaAiBase,
+                deployment: this.azureDalleDeployment,
+                apiVersion: "2024-10-21",
+            });
+        }
+        else {
+            // fallback to standard OpenAI
+            client = new OpenAI({
+                apiKey: this.openAiKey,
+            });
+        }
+        // Decide on image dimensions
+        let size = "1792x1024";
+        if (type === "logo") {
+            size = "1792x1024";
+        }
+        else if (type === "icon") {
+            size = "1024x1024";
+        }
+        while (retrying && retryCount < this.maxRetryCount) {
+            try {
+                // If using Azure OpenAI
+                if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+                    result = await client.images.generate({
+                        prompt,
+                        n: 1,
+                        size,
+                        quality: "hd",
+                    });
+                }
+                else {
+                    // Standard OpenAI
+                    result = await client.images.generate({
+                        model: "dall-e-3",
+                        prompt,
+                        n: 1,
+                        size,
+                        quality: "hd",
+                    });
+                }
+                if (result) {
+                    retrying = false;
+                }
+                else {
+                    console.debug("Result: NONE");
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with DALL·E, retrying...");
+                console.warn(error.stack);
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} milliseconds`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (result && result.data && result.data[0].url) {
+            return result.data[0].url;
+        }
+        else {
+            console.error(`Error generating image after ${retryCount} retries`);
+            return undefined;
+        }
+    }
+}

package/active-citizen/llms/imageGeneration/fluxImageGenerator.js

@@ -0,0 +1,49 @@
+import Replicate from "replicate";
+export class FluxImageGenerator {
+    constructor(replicateApiKey, fluxProModelName) {
+        this.replicateApiKey = replicateApiKey;
+        this.fluxProModelName = fluxProModelName;
+        this.maxRetryCount = 3;
+        this.replicate = new Replicate({ auth: replicateApiKey });
+    }
+    async generateImageUrl(prompt, type = "logo") {
+        let retryCount = 0;
+        let retrying = true;
+        let result;
+        // Configure the input to replicate’s model
+        const input = { prompt };
+        // Assign aspect ratio depending on type
+        if (type === "logo") {
+            input.aspect_ratio = "16:9";
+        }
+        else if (type === "icon") {
+            input.aspect_ratio = "1:1";
+        }
+        else {
+            input.aspect_ratio = "16:9";
+        }
+        while (retrying && retryCount < this.maxRetryCount) {
+            try {
+                result = await this.replicate.run(this.fluxProModelName, {
+                    input,
+                });
+                if (result) {
+                    retrying = false;
+                    return result; // typically a single URL
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with Flux, retrying...");
+                console.warn(error.stack);
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} milliseconds`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (!result) {
+            console.error(`Error generating image after ${retryCount} retries`);
+        }
+        return undefined;
+    }
+}

package/active-citizen/llms/imageGeneration/iImageGenerator.js

@@ -0,0 +1 @@
+export {};

package/active-citizen/llms/imageGeneration/imageProcessorService.js

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+import { v4 as uuidv4 } from "uuid";
+export class ImageProcessorService {
+    constructor() {
+        this.validFormats = ["jpeg", "png", "webp", "gif", "tiff", "avif", "svg"];
+    }
+    /**
+     * Downloads an image from a given URL into the specified filepath.
+     */
+    async downloadImage(imageUrl, imageFilePath, axiosInstance) {
+        const response = await axiosInstance({
+            method: "GET",
+            url: imageUrl,
+            responseType: "stream",
+        });
+        const writer = fs.createWriteStream(imageFilePath);
+        response.data.pipe(writer);
+        return new Promise((resolve, reject) => {
+            writer.on("finish", () => resolve());
+            writer.on("error", reject);
+        });
+    }
+    /**
+     * Resizes an image to given dimensions (width x height).
+     * If the image is smaller, it won't be enlarged.
+     */
+    async resizeImage(imagePath, width, height) {
+        const resizedImageFilePath = path.join("/tmp", `${uuidv4()}.png`);
+        try {
+            // 1) Initialize Sharp instance
+            const image = sharp(imagePath).rotate(); // rotate fixes orientation from EXIF
+            // 2) Read metadata to validate format
+            const metadata = await image.metadata();
+            if (!metadata.format || !this.validFormats.includes(metadata.format)) {
+                throw new Error(`Unsupported format: ${metadata.format} (expected one of ${this.validFormats.join(", ")})`);
+            }
+            // 3) Resize + convert
+            await image
+                .resize({
+                width,
+                height,
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .toFormat("png", {
+                quality: 90,
+                progressive: true,
+            })
+                .toFile(resizedImageFilePath);
+            // 4) Remove the original file
+            fs.unlinkSync(imagePath);
+            return resizedImageFilePath;
+        }
+        catch (err) {
+            console.error("Error resizing image:", err);
+            if (fs.existsSync(resizedImageFilePath)) {
+                fs.unlinkSync(resizedImageFilePath);
+            }
+            throw err;
+        }
+    }
+}