@yrpri/api 9.0.103 → 9.0.104

package/dist/active-citizen/llms/baseChatBot.js

@@ -1,183 +0,0 @@
-import { OpenAI } from "openai";
-const DEBUG = false;
-const url = process.env.REDIS_MEMORY_URL ||
-    process.env.REDIS_URL ||
-    "redis://localhost:6379";
-const tlsOptions = url.startsWith("rediss://")
-    ? { rejectUnauthorized: false }
-    : undefined;
-export class YpBaseChatBot {
-    destroy() {
-        this.wsClientSocket = undefined;
-    }
-    loadMemory() {
-        return new Promise(async (resolve, reject) => {
-            try {
-                console.log("loadMemoryWithOwnership loadMemory: redisKey: ", this.redisKey);
-                const memoryString = await this.redis.get(this.redisKey);
-                if (memoryString) {
-                    const memory = JSON.parse(memoryString);
-                    resolve(memory);
-                }
-                else {
-                    console.error("loadMemoryWithOwnership loadMemory: no memory found");
-                    resolve(undefined);
-                }
-            }
-            catch (error) {
-                console.error("loadMemoryWithOwnership loadMemory: Can't load memory from redis", error);
-                resolve(undefined);
-            }
-        });
-    }
-    constructor(wsClientId, wsClients, redisConnection, redisKey) {
-        this.temperature = 0.7;
-        this.maxTokens = 16000;
-        this.llmModel = "gpt-4o";
-        this.persistMemory = false;
-        this.redis = redisConnection;
-        this.redisKey = redisKey;
-        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,
-        });
-    }
-    async saveMemory() {
-        if (this.memory) {
-            try {
-                await this.redis.set(this.redisKey, JSON.stringify(this.memory));
-                console.log(`Saved memory to redis: ${this.redisKey}`);
-            }
-            catch (error) {
-                console.log("Can't save memory to redis", error);
-            }
-        }
-        else {
-            console.error("Memory is not initialized");
-        }
-    }
-    renderSystemPrompt() {
-        return `Please tell the user to replace this system prompt in a fun and friendly way. Encourage them to have a nice day. Lots of emojis`;
-    }
-    sendAgentStart(name, hasNoStreaming = true) {
-        const botMessage = {
-            sender: "assistant",
-            type: "agentStart",
-            data: {
-                name: name,
-                noStreaming: hasNoStreaming,
-            },
-        };
-        this.wsClientSocket.send(JSON.stringify(botMessage));
-    }
-    sendAgentCompleted(name, lastAgent = false, error = undefined) {
-        const botMessage = {
-            sender: "assistant",
-            type: "agentCompleted",
-            data: {
-                name: name,
-                results: {
-                    isValid: true,
-                    validationErrors: error,
-                    lastAgent: lastAgent,
-                },
-            },
-        };
-        this.wsClientSocket.send(JSON.stringify(botMessage));
-    }
-    sendAgentUpdate(message) {
-        const botMessage = {
-            sender: "assistant",
-            type: "agentUpdated",
-            message: message,
-        };
-        this.wsClientSocket.send(JSON.stringify(botMessage));
-    }
-    sendToClient(sender, message, type = "stream", uniqueToken = undefined, hiddenContextMessage = false) {
-        try {
-            if (process.env.WS_DEBUG) {
-                console.log(`sendToClient: ${JSON.stringify({ sender, type, message, hiddenContextMessage }, null, 2)}`);
-            }
-            this.wsClientSocket.send(JSON.stringify({
-                sender,
-                type: type,
-                message: type === "html" ? undefined : message,
-                html: type === "html" ? message : undefined,
-                hiddenContextMessage,
-                uniqueToken,
-                avatarUrl: sender === "assistant" ? this.currentAssistantAvatarUrl : undefined,
-            }));
-            this.lastSentToUserAt = new Date();
-        }
-        catch (error) {
-            console.error("Can't send message to client", error);
-        }
-    }
-    async streamWebSocketResponses(stream) {
-        return new Promise(async (resolve, reject) => {
-            this.sendToClient("assistant", "", "start", this.currentAssistantAvatarUrl);
-            try {
-                let botMessage = "";
-                for await (const part of stream) {
-                    this.sendToClient("assistant", part.choices[0].delta.content);
-                    botMessage += part.choices[0].delta.content;
-                    if (part.choices[0].finish_reason == "stop") {
-                        this.memory.chatLog.push({
-                            sender: "assistant",
-                            message: botMessage,
-                            type: "message",
-                        });
-                        await this.saveMemoryIfNeeded();
-                    }
-                }
-            }
-            catch (error) {
-                console.error(error);
-                this.sendToClient("assistant", "There has been an error, please retry", "error");
-                reject();
-            }
-            finally {
-                this.sendToClient("assistant", "", "end");
-            }
-            resolve();
-        });
-    }
-    async saveMemoryIfNeeded() {
-        if (this.persistMemory) {
-            await this.saveMemory();
-        }
-    }
-    async setChatLog(chatLog) {
-        this.memory.chatLog = chatLog;
-        await this.saveMemoryIfNeeded();
-    }
-    async conversation(chatLog) {
-        this.setChatLog(chatLog);
-        let messages = chatLog.map((message) => {
-            return {
-                role: message.sender,
-                content: message.message,
-            };
-        });
-        const systemMessage = {
-            role: "system",
-            content: this.renderSystemPrompt(),
-        };
-        messages.unshift(systemMessage);
-        const stream = await this.openaiClient.chat.completions.create({
-            model: this.llmModel,
-            messages,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            stream: true,
-        });
-        this.streamWebSocketResponses(stream);
-    }
-}
-YpBaseChatBot.redisMemoryKeyPrefix = "yp-chatbot-memory-v4";

package/dist/active-citizen/llms/imageGeneration/chatGptImageGenerator.js

@@ -1,56 +0,0 @@
-// chatGptImageGenerator.ts
-import { OpenAI } from "openai";
-export class ChatGptImageGenerator {
-    constructor(openAiKey) {
-        this.maxRetryCount = 3;
-        // the SDK will fall back to process.env.OPENAI_API_KEY if nothing is passed
-        this.openAiKey = openAiKey;
-    }
-    /**
-     * Generates an image URL from a prompt using OpenAI’s gpt-image-1 model.
-     * The returned link remains live for ~60 minutes – be sure to download
-     * or cache it right away in the calling service.
-     */
-    async generateImageUrl(prompt, type = "logo") {
-        const client = new OpenAI({ apiKey: this.openAiKey });
-        // Pick a sensible canvas size from the image type
-        let size = "1536x1024";
-        if (type === "icon")
-            size = "1024x1024";
-        else if (type === "other")
-            size = "1536x1024";
-        const finalPrompt = `
-    ${prompt}
-
-    Instruction: Create a high quality logo like image for the users project and follow their style instructions. \
-    Do not add text to the images unless asked in the style instructions.
-    `;
-        let retryCount = 0;
-        while (retryCount < this.maxRetryCount) {
-            try {
-                const res = await client.images.generate({
-                    model: "gpt-image-1",
-                    prompt: finalPrompt,
-                    quality: "medium",
-                    n: 1,
-                    size
-                });
-                const url = res?.data?.[0]?.url;
-                if (url)
-                    return url;
-                throw new Error("No URL returned");
-            }
-            catch (err) {
-                retryCount += 1;
-                if (retryCount >= this.maxRetryCount) {
-                    console.error(`ChatGptImageGenerator failed after ${retryCount} attempts`, err);
-                    return undefined;
-                }
-                // Exponential back-off – starts at 5 s and grows +5 s each retry
-                await new Promise((r) => setTimeout(r, 5000 + retryCount * 5000));
-            }
-        }
-        return undefined;
-    }
-}
-export default ChatGptImageGenerator;

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

@@ -1,109 +0,0 @@
-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";
-import { ChatGptImageGenerator } from "./chatGptImageGenerator.js";
-// For reference, in your code:
-const dbModels = models;
-const Image = dbModels.Image;
-const AcBackgroundJob = dbModels.AcBackgroundJob;
-const disableFlux = false;
-const useImagen = false;
-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);
-        this.chatGptImageGenerator = new ChatGptImageGenerator(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 if (process.env.USE_CHATGPT_IMAGE_GENERATOR) {
-                    imageGenerator = this.chatGptImageGenerator;
-                    console.info("Using ChatGptImageGenerator");
-                }
-                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/dist/active-citizen/llms/imageGeneration/dalleImageGenerator.js

@@ -1,84 +0,0 @@
-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";
-        }
-        const modelQuality = "standard";
-        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: modelQuality,
-                    });
-                }
-                else {
-                    // Standard OpenAI
-                    result = await client.images.generate({
-                        model: "dall-e-3",
-                        prompt,
-                        n: 1,
-                        size,
-                        quality: modelQuality,
-                    });
-                }
-                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/dist/active-citizen/llms/imageGeneration/fluxImageGenerator.js

@@ -1,49 +0,0 @@
-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/dist/active-citizen/llms/imageGeneration/iImageGenerator.js

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

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

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

package/dist/active-citizen/llms/imageGeneration/imagenImageGenerator.js

@@ -1,107 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { v4 as uuidv4 } from "uuid";
-import { PredictionServiceClient } from "@google-cloud/aiplatform";
-import { helpers } from "@google-cloud/aiplatform";
-export class ImagenImageGenerator {
-    constructor(s3Service) {
-        this.s3Service = s3Service;
-        this.maxRetryCount = 3;
-        // Pull these from your environment or config
-        this.projectId = process.env.GOOGLE_CLOUD_PROJECT_ID || "";
-        this.location = process.env.GOOGLE_CLOUD_IMAGEN_LOCATION || "us-east1";
-        // Matches the official endpoint for Imagen v3.0:
-        this.endpoint = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/imagen-3.0-generate-002`;
-        this.s3Bucket = process.env.S3_BUCKET || "";
-        if (!this.projectId) {
-            console.warn("Warning: GOOGLE_CLOUD_PROJECT_ID is not set. Vertex AI calls may fail.");
-        }
-        if (!this.s3Bucket) {
-            console.warn("Warning: S3_BUCKET is not set. Image upload may fail.");
-        }
-    }
-    /**
-     * Generates an image from a text prompt using Vertex AI Imagen
-     * and returns a public S3 URL to the uploaded image.
-     */
-    async generateImageUrl(prompt, type = "logo") {
-        let retryCount = 0;
-        let finalUrl;
-        // Configure the API endpoint for Vertex AI
-        const clientOptions = {
-            apiEndpoint: `${this.location}-aiplatform.googleapis.com`,
-        };
-        const predictionServiceClient = new PredictionServiceClient(clientOptions);
-        while (retryCount < this.maxRetryCount && !finalUrl) {
-            try {
-                // 1) Prepare the prompt and parameters for Imagen
-                const promptText = {
-                    prompt: prompt, // The text prompt describing what you want to see
-                };
-                const instanceValue = helpers.toValue(promptText);
-                const instances = [instanceValue];
-                const parameter = {
-                    sampleCount: 1,
-                    // You can tweak these settings to your needs:
-                    // seed: 100,
-                    // addWatermark: false,
-                    aspectRatio: "16:9",
-                    safetyFilterLevel: "block_some",
-                    personGeneration: "allow_adult",
-                };
-                const parameters = helpers.toValue(parameter);
-                // 2) Build the predict request
-                const request = {
-                    endpoint: this.endpoint,
-                    instances,
-                    parameters,
-                };
-                // 3) Make the API call
-                //@ts-ignore
-                const [response] = await predictionServiceClient.predict(request);
-                const predictions = response.predictions;
-                if (!predictions || predictions.length === 0) {
-                    console.warn("No image was generated. Check the request parameters and prompt.");
-                }
-                else {
-                    // 4) Extract base64 data from the first prediction
-                    const prediction = predictions[0];
-                    const b64Data = prediction.structValue?.fields?.bytesBase64Encoded?.stringValue;
-                    if (!b64Data) {
-                        throw new Error("Prediction did not contain base64 image data.");
-                    }
-                    // 5) Decode and write to a temporary file
-                    const buff = Buffer.from(b64Data, "base64");
-                    const tmpFilePath = path.join("/tmp", `${uuidv4()}.png`);
-                    fs.writeFileSync(tmpFilePath, buff);
-                    // 6) Upload the image to S3
-                    const s3Key = `imagenAi/${uuidv4()}.png`;
-                    await this.s3Service.uploadImageToS3(this.s3Bucket, tmpFilePath, s3Key);
-                    // 7) Construct a public URL (optionally using Cloudflare)
-                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
-                        finalUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3Key}`;
-                    }
-                    else {
-                        finalUrl = `https://${this.s3Bucket}.s3.amazonaws.com/${s3Key}`;
-                    }
-                }
-            }
-            catch (error) {
-                console.warn("Error generating image with Vertex AI Imagen. Will retry...");
-                console.warn(error?.message || error);
-            }
-            // Retry logic
-            if (!finalUrl) {
-                retryCount++;
-                const sleepingFor = 5000 + retryCount * 10000;
-                console.debug(`Sleeping for ${sleepingFor} ms before retry #${retryCount}...`);
-                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
-            }
-        }
-        if (!finalUrl) {
-            console.error(`Failed to generate Imagen after ${retryCount} retries.`);
-            return undefined;
-        }
-        return finalUrl;
-    }
-}