@yrpri/api 9.0.231 → 9.0.233

package/services/engine/moderation/fraud/FraudRequestValidation.cjs

@@ -0,0 +1,143 @@
+"use strict";
+const MAX_FRAUD_IDS_TO_DELETE = 1000;
+const validActionTypes = new Set(["get-items", "delete-one-item", "delete-items"]);
+const validCollectionTypes = new Set([
+    "endorsements",
+    "ratings",
+    "pointQualities",
+    "points",
+    "posts",
+]);
+const commonMethods = new Set([
+    "byIpFingerprint",
+    "byMissingBrowserFingerprint",
+    "byIpAddress",
+]);
+const postMethods = new Set([
+    ...commonMethods,
+    "byIpFingerprintPostId",
+    "byIpUserAgentPostId",
+]);
+const pointMethods = new Set([
+    ...commonMethods,
+    "byIpFingerprintPointId",
+    "byIpUserAgentPointId",
+]);
+const normalizeIdValue = (value) => {
+    if (typeof value === "number") {
+        return Number.isSafeInteger(value) && value > 0 ? value : null;
+    }
+    else if (typeof value === "string") {
+        const trimmedValue = value.trim();
+        if (!/^[1-9]\d*$/.test(trimmedValue)) {
+            return null;
+        }
+        const parsedValue = Number(trimmedValue);
+        return Number.isSafeInteger(parsedValue) ? parsedValue : null;
+    }
+    else {
+        return null;
+    }
+};
+const validateIdsToDelete = (idsToDelete) => {
+    if (idsToDelete === undefined || idsToDelete === null) {
+        return { idsToDelete: [] };
+    }
+    if (!Array.isArray(idsToDelete)) {
+        return {
+            error: "invalid_ids_to_delete",
+            idsToDelete: [],
+        };
+    }
+    if (idsToDelete.length > MAX_FRAUD_IDS_TO_DELETE) {
+        return {
+            error: "too_many_ids_to_delete",
+            idsToDelete: [],
+        };
+    }
+    const seenIds = new Set();
+    const normalizedIds = [];
+    for (let i = 0; i < idsToDelete.length; i++) {
+        const normalizedId = normalizeIdValue(idsToDelete[i]);
+        if (!normalizedId) {
+            return {
+                error: "invalid_ids_to_delete",
+                idsToDelete: [],
+            };
+        }
+        if (!seenIds.has(normalizedId)) {
+            seenIds.add(normalizedId);
+            normalizedIds.push(normalizedId);
+        }
+    }
+    return { idsToDelete: normalizedIds };
+};
+const normalizeIdsToDelete = (idsToDelete) => {
+    return validateIdsToDelete(idsToDelete).idsToDelete;
+};
+const getValidMethodsForCollectionType = (collectionType) => {
+    if (collectionType === "pointQualities") {
+        return pointMethods;
+    }
+    else if (collectionType === "posts") {
+        return commonMethods;
+    }
+    else {
+        return postMethods;
+    }
+};
+const validateFraudActionRequest = ({ type, selectedMethod, collectionType, idsToDelete, }) => {
+    if (!validActionTypes.has(type)) {
+        return {
+            error: "invalid_fraud_action_type",
+            idsToDelete: [],
+        };
+    }
+    if (!validCollectionTypes.has(collectionType)) {
+        return {
+            error: "invalid_fraud_collection_type",
+            idsToDelete: [],
+        };
+    }
+    const validMethods = getValidMethodsForCollectionType(collectionType);
+    if (!validMethods.has(selectedMethod)) {
+        return {
+            error: "invalid_fraud_detection_method",
+            idsToDelete: [],
+        };
+    }
+    const idsValidation = validateIdsToDelete(idsToDelete);
+    const normalizedIdsToDelete = idsValidation.idsToDelete;
+    if (idsValidation.error) {
+        return idsValidation;
+    }
+    if ((type === "delete-one-item" || type === "delete-items") &&
+        normalizedIdsToDelete.length === 0) {
+        return {
+            error: "delete_requires_ids",
+            idsToDelete: normalizedIdsToDelete,
+        };
+    }
+    if (type === "delete-one-item" && normalizedIdsToDelete.length !== 1) {
+        return {
+            error: "single_delete_requires_one_id",
+            idsToDelete: normalizedIdsToDelete,
+        };
+    }
+    if (selectedMethod === "byMissingBrowserFingerprint" &&
+        (type === "delete-items" || normalizedIdsToDelete.length > 1)) {
+        return {
+            error: "bulk_delete_missing_fingerprint_disabled",
+            idsToDelete: normalizedIdsToDelete,
+        };
+    }
+    return {
+        idsToDelete: normalizedIdsToDelete,
+    };
+};
+module.exports = {
+    MAX_FRAUD_IDS_TO_DELETE,
+    normalizeIdsToDelete,
+    validateFraudActionRequest,
+    validateIdsToDelete,
+};

package/services/engine/moderation/fraud/FraudRequestValidation.d.cts

@@ -0,0 +1,21 @@
+export const MAX_FRAUD_IDS_TO_DELETE: 1000;
+export function normalizeIdsToDelete(idsToDelete: any): number[] | never[];
+export function validateFraudActionRequest({ type, selectedMethod, collectionType, idsToDelete, }: {
+    type: any;
+    selectedMethod: any;
+    collectionType: any;
+    idsToDelete: any;
+}): {
+    error: string;
+    idsToDelete: number[] | never[];
+} | {
+    idsToDelete: number[] | never[];
+    error?: undefined;
+};
+export function validateIdsToDelete(idsToDelete: any): {
+    error: string;
+    idsToDelete: never[];
+} | {
+    idsToDelete: number[];
+    error?: undefined;
+};

package/services/engine/moderation/fraud/FraudScannerNotifier.cjs

@@ -4,9 +4,11 @@ const models = require("../../../../models/index.cjs");
 const i18n = require('../../../utils/i18n.cjs');
 const deepEqual = require('deep-equal');
 const log = require("../../../../utils/logger.cjs");
-const FraudGetEndorsements = require("./FraudGetEndorsements");
-const FraudGetPointQualities = require("./FraudGetPointQualities");
-const FraudGetRatings = require("./FraudGetRatings");
+const FraudGetEndorsements = require("./FraudGetEndorsements.cjs");
+const FraudGetPointQualities = require("./FraudGetPointQualities.cjs");
+const FraudGetRatings = require("./FraudGetRatings.cjs");
+const FraudGetPoints = require("./FraudGetPoints.cjs");
+const FraudGetPosts = require("./FraudGetPosts.cjs");
 const queue = require("../../../workers/queue.cjs");
 const Backend = require("i18next-fs-backend");
 const path = require("path");
@@ -15,8 +17,17 @@ class FraudScannerNotifier {
     constructor() {
         this.currentCommunity = null;
         this.uniqueCollectionItemsIds = {};
-        this.collectionsToScan = ['endorsements', 'ratings', 'pointQualities'];
-        this.scannerModels = [FraudGetEndorsements, FraudGetRatings, FraudGetPointQualities];
+        this.collectionsToScan = ['endorsements', 'ratings', 'pointQualities', 'points', 'posts'];
+        this.scannerModels = [
+            FraudGetEndorsements,
+            FraudGetRatings,
+            FraudGetPointQualities,
+            FraudGetPoints,
+            FraudGetPosts
+        ];
+    }
+    resetCounts() {
+        this.uniqueCollectionItemsIds = {};
     }
     getCommunityURL() {
         if (this.currentCommunity && this.currentCommunity.Domain && this.currentCommunity.Domain.domain_name) {
@@ -134,7 +145,7 @@ class FraudScannerNotifier {
     }
     getContainerOldCount(collectionType) {
         let foundCollection;
-        if (this.currentCommunity.data.lastFraudScanResults) {
+        if (this.currentCommunity.data && this.currentCommunity.data.lastFraudScanResults) {
             for (let i = 0; i < this.currentCommunity.data.lastFraudScanResults.length; i++) {
                 if (this.currentCommunity.data.lastFraudScanResults[i].collectionType &&
                     this.currentCommunity.data.lastFraudScanResults[i].collectionType === collectionType) {
@@ -187,7 +198,7 @@ class FraudScannerNotifier {
             if (this.collectionsToScan[c] === "pointQualities") {
                 methodsToScan = methodsToScan.concat(['byIpFingerprintPointId', 'byIpUserAgentPointId']);
             }
-            else {
+            else if (this.collectionsToScan[c] !== "posts") {
                 methodsToScan = methodsToScan.concat(['byIpFingerprintPostId', 'byIpUserAgentPostId']);
             }
             for (let m = 0; m < methodsToScan.length; m++) {
@@ -230,6 +241,7 @@ class FraudScannerNotifier {
                 for (let i = 0; i < communities.length; i++) {
                     log.info("Processing community: " + communities[i].name);
                     this.currentCommunity = communities[i];
+                    this.resetCounts();
                     try {
                         await this.scan();
                         await this.notify();
@@ -249,32 +261,44 @@ class FraudScannerNotifier {
         });
     }
 }
-i18n
-    .use(Backend)
-    .init({
-    preload: ['en', 'fr', 'sk', 'bg', 'cs', 'it', 'da', 'kl', 'es', 'sv', 'sq', 'uz', 'uk', 'ca', 'hr', 'ro', 'ru',
-        'ro_md', 'pt_br', 'hu', 'tr', 'is', 'nl', 'no', 'pl', 'zh_tw', 'ky'],
-    fallbackLng: 'en',
-    // this is the defaults
-    backend: {
-        // path where resources get loaded from
-        loadPath: localesPath + '/{{lng}}/translation.json',
-        // path to post missing resources
-        addPath: localesPath + '/{{lng}}/translation.missing.json',
-        // jsonIndent to use when storing json files
-        jsonIndent: 2
-    }
-}, function (err, t) {
-    (async () => {
-        try {
-            const scanner = new FraudScannerNotifier();
-            await scanner.scanAndNotify();
-            log.info("Fraud Scanning Complete");
-            process.exit();
-        }
-        catch (error) {
-            log.error(error);
-            process.exit();
+const runFraudScannerNotifier = () => {
+    i18n
+        .use(Backend)
+        .init({
+        preload: ['en', 'fr', 'sk', 'bg', 'cs', 'it', 'da', 'kl', 'es', 'sv', 'sq', 'uz', 'uk', 'ca', 'hr', 'ro', 'ru',
+            'ro_md', 'pt_br', 'hu', 'tr', 'is', 'nl', 'no', 'pl', 'zh_tw', 'ky'],
+        fallbackLng: 'en',
+        // this is the defaults
+        backend: {
+            // path where resources get loaded from
+            loadPath: localesPath + '/{{lng}}/translation.json',
+            // path to post missing resources
+            addPath: localesPath + '/{{lng}}/translation.missing.json',
+            // jsonIndent to use when storing json files
+            jsonIndent: 2
         }
-    })();
-});
+    }, function (err, t) {
+        (async () => {
+            try {
+                if (err) {
+                    throw err;
+                }
+                const scanner = new FraudScannerNotifier();
+                await scanner.scanAndNotify();
+                log.info("Fraud Scanning Complete");
+                process.exit(0);
+            }
+            catch (error) {
+                log.error(error);
+                process.exit(1);
+            }
+        })();
+    });
+};
+if (require.main === module) {
+    runFraudScannerNotifier();
+}
+module.exports = {
+    FraudScannerNotifier,
+    runFraudScannerNotifier
+};

package/services/engine/moderation/fraud/FraudScannerNotifier.d.cts

@@ -1 +1,20 @@
-export {};
+export class FraudScannerNotifier {
+    currentCommunity: (import("sequelize").Model<YpCommunityData, Partial<YpCommunityData>> & YpCommunityData) | null;
+    uniqueCollectionItemsIds: {};
+    collectionsToScan: string[];
+    scannerModels: (typeof FraudGetPoints)[];
+    resetCounts(): void;
+    getCommunityURL(): string;
+    setupCounts(items: any, collectionType: any): void;
+    capitalizeFirstLetter(string: any): any;
+    formatNumber(value: any): any;
+    getNumberSign(number: any): "" | "+";
+    sendNotificationEmails(fraudAuditResults: any): Promise<void>;
+    getContainerOldCount(collectionType: any): any;
+    getWithDifference(results: any): any;
+    notify(): Promise<void>;
+    scan(): Promise<void>;
+    scanAndNotify(): Promise<any>;
+}
+export function runFraudScannerNotifier(): void;
+import FraudGetPoints = require("./FraudGetPoints.cjs");

package/services/llms/baseChatBot.d.ts

@@ -26,6 +26,8 @@ export declare class YpBaseChatBot {
     sendAgentUpdate(message: string): void;
     sendToClient(sender: YpSenderType, message: string, type?: YpAssistantMessageType, uniqueToken?: string | undefined, hiddenContextMessage?: boolean): void;
     streamWebSocketResponses(stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>): Promise<void>;
+    usesMaxCompletionTokens(modelName: string): boolean;
+    getStreamingChatCompletionParams(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[]): OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming;
     saveMemoryIfNeeded(): Promise<void>;
     setChatLog(chatLog: YpSimpleChatLog[]): Promise<void>;
     conversation(chatLog: YpSimpleChatLog[]): Promise<void>;

package/services/llms/baseChatBot.js

@@ -41,6 +41,7 @@ export class YpBaseChatBot {
         this.wsClientId = wsClientId;
         this.wsClientSocket = wsClients.get(this.wsClientId);
         this.wsClients = wsClients;
+        this.memory = { chatLog: [] };
         log.info(`WebSockets: BaseChatBot constructor for ${this.wsClientId}`);
         if (!this.wsClientSocket) {
             log.error(`WebSockets: WS Client ${this.wsClientId} not found in streamWebSocketResponses`);
@@ -126,8 +127,11 @@ export class YpBaseChatBot {
             try {
                 let botMessage = "";
                 for await (const part of stream) {
-                    this.sendToClient("assistant", part.choices[0].delta.content);
-                    botMessage += part.choices[0].delta.content;
+                    const content = part.choices[0].delta.content;
+                    if (content) {
+                        this.sendToClient("assistant", content);
+                        botMessage += content;
+                    }
                     if (part.choices[0].finish_reason == "stop") {
                         this.memory.chatLog.push({
                             sender: "assistant",
@@ -149,6 +153,24 @@ export class YpBaseChatBot {
             resolve();
         });
     }
+    usesMaxCompletionTokens(modelName) {
+        return modelName.startsWith("gpt-5");
+    }
+    getStreamingChatCompletionParams(messages) {
+        const requestParams = {
+            model: this.llmModel,
+            messages,
+            stream: true,
+        };
+        if (this.usesMaxCompletionTokens(this.llmModel)) {
+            requestParams.max_completion_tokens = this.maxTokens;
+        }
+        else {
+            requestParams.max_tokens = this.maxTokens;
+            requestParams.temperature = this.temperature;
+        }
+        return requestParams;
+    }
     async saveMemoryIfNeeded() {
         if (this.persistMemory) {
             await this.saveMemory();
@@ -171,13 +193,7 @@ export class YpBaseChatBot {
             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,
-        });
+        const stream = await this.openaiClient.chat.completions.create(this.getStreamingChatCompletionParams(messages));
         this.streamWebSocketResponses(stream);
     }
 }

package/services/llms/imageGeneration/chatGptImageGenerator.d.ts

@@ -1,4 +1,4 @@
-import { IImageGenerator, YpAiGenerateImageTypes } from "./iImageGenerator.js";
+import { IImageGenerator, YpAiGenerateImageTypes, YpImageGenerationOptions } from "./iImageGenerator.js";
 export declare class ChatGptImageGenerator implements IImageGenerator {
     private readonly maxRetryCount;
     private readonly openAiKey?;
@@ -8,6 +8,6 @@ export declare class ChatGptImageGenerator implements IImageGenerator {
      * The returned link remains live for ~60 minutes – be sure to download
      * or cache it right away in the calling service.
      */
-    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes): Promise<string | undefined>;
+    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes, options?: YpImageGenerationOptions): Promise<string | undefined>;
 }
 export default ChatGptImageGenerator;

package/services/llms/imageGeneration/chatGptImageGenerator.js

@@ -1,6 +1,8 @@
 // chatGptImageGenerator.ts
 import { OpenAI } from "openai";
 import log from "../../../utils/loggerTs.js";
+import imageModelConfig from "./imageModelConfig.cjs";
+const { defaultOpenAiImageModel, getDefaultImageQualityForOptions, getDefaultImageSizeForOptions, } = imageModelConfig;
 export class ChatGptImageGenerator {
     constructor(openAiKey) {
         this.maxRetryCount = 3;
@@ -12,14 +14,15 @@ export class ChatGptImageGenerator {
      * 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") {
+    async generateImageUrl(prompt, type = "logo", options) {
         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 model = options?.imageModel || defaultOpenAiImageModel;
+        const size = options?.imageSize ||
+            getDefaultImageSizeForOptions("openai", model, type) ||
+            "1536x1024";
+        const quality = options?.imageQuality ||
+            getDefaultImageQualityForOptions("openai", model) ||
+            "medium";
         const finalPrompt = `
     ${prompt}
 
@@ -30,11 +33,11 @@ export class ChatGptImageGenerator {
         while (retryCount < this.maxRetryCount) {
             try {
                 const res = await client.images.generate({
-                    model: "gpt-image-1",
+                    model,
                     prompt: finalPrompt,
-                    quality: "medium",
+                    quality: quality,
                     n: 1,
-                    size,
+                    size: size,
                 });
                 log.info("res", JSON.stringify(res, null, 2));
                 const b64Json = res?.data?.[0]?.b64_json;

package/services/llms/imageGeneration/collectionImageGenerator.js

@@ -11,12 +11,13 @@ import log from "../../../utils/loggerTs.js";
 import models from "../../../models/index.cjs";
 import { ImagenImageGenerator } from "./imagenImageGenerator.js";
 import { ChatGptImageGenerator } from "./chatGptImageGenerator.js";
+import imageModelConfig from "./imageModelConfig.cjs";
 // For reference, in your code:
 const dbModels = models;
 const Image = dbModels.Image;
 const AcBackgroundJob = dbModels.AcBackgroundJob;
 const disableFlux = false;
-const useImagen = false;
+const { isOpenAiDalleImageModel, isOpenAiGptImageModel, normalizeImageGenerationOptions, } = imageModelConfig;
 export class CollectionImageGenerator {
     constructor() {
         this.s3Service = new S3Service(process.env.CLOUDFLARE_API_KEY, process.env.CLOUDFLARE_ZONE_ID);
@@ -29,7 +30,7 @@ export class CollectionImageGenerator {
         }
         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) {
+        if (process.env.GOOGLE_CLOUD_PROJECT_ID) {
             this.imagenImageGenerator = new ImagenImageGenerator(this.s3Service);
         }
     }
@@ -44,29 +45,46 @@ export class CollectionImageGenerator {
             const s3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}.png`;
             try {
                 let imageGenerator;
-                // Decide which generator to use
-                if (this.imagenImageGenerator) {
+                const rawImageOptions = normalizeImageGenerationOptions(workPackage.imageProvider, workPackage.imageModel, workPackage.imageSize, workPackage.imageQuality);
+                if (rawImageOptions.error) {
+                    return reject(rawImageOptions.error);
+                }
+                const imageOptions = rawImageOptions;
+                if (imageOptions.imageProvider === "imagen") {
+                    if (!this.imagenImageGenerator) {
+                        return reject("Imagen image generator is not configured.");
+                    }
                     imageGenerator = this.imagenImageGenerator;
-                    log.info("Using ImagenImageGenerator");
+                    log.info(`Using ImagenImageGenerator: ${imageOptions.imageModel}`);
                 }
-                else if (this.fluxImageGenerator) {
+                else if (imageOptions.imageProvider === "flux") {
+                    if (!this.fluxImageGenerator) {
+                        return reject("Flux image generator is not configured.");
+                    }
                     imageGenerator = this.fluxImageGenerator;
-                    log.info("Using FluxImageGenerator");
+                    log.info(`Using FluxImageGenerator: ${imageOptions.imageModel}`);
+                }
+                else if (imageOptions.imageProvider === "azureOpenai") {
+                    imageGenerator = this.dalleImageGenerator;
+                    log.info(`Using Azure OpenAI image generator: ${imageOptions.imageModel}`);
+                }
+                else if (isOpenAiDalleImageModel(imageOptions.imageModel)) {
+                    imageGenerator = this.dalleImageGenerator;
+                    log.info(`Using DalleImageGenerator: ${imageOptions.imageModel}`);
                 }
-                else if (process.env.USE_CHATGPT_IMAGE_GENERATOR) {
+                else if (isOpenAiGptImageModel(imageOptions.imageModel)) {
                     imageGenerator = this.chatGptImageGenerator;
-                    log.info("Using ChatGptImageGenerator");
+                    log.info(`Using ChatGptImageGenerator: ${imageOptions.imageModel}`);
                 }
                 else {
-                    imageGenerator = this.dalleImageGenerator;
-                    log.info("Using DalleImageGenerator");
+                    return reject(`Unsupported OpenAI image model: ${imageOptions.imageModel}`);
                 }
                 // 1) Generate image
-                const imageUrl = await imageGenerator.generateImageUrl(workPackage.prompt, workPackage.imageType);
+                const imageUrl = await imageGenerator.generateImageUrl(workPackage.prompt, workPackage.imageType, imageOptions);
                 if (!imageUrl) {
                     return reject("Error getting image URL from prompt.");
                 }
-                if (useImagen && this.imagenImageGenerator) {
+                if (imageOptions.imageProvider === "imagen") {
                     newImageUrl = imageUrl;
                 }
                 else {

package/services/llms/imageGeneration/dalleImageGenerator.d.ts

@@ -1,4 +1,4 @@
-import { IImageGenerator, YpAiGenerateImageTypes } from "./iImageGenerator.js";
+import { IImageGenerator, YpAiGenerateImageTypes, YpImageGenerationOptions } from "./iImageGenerator.js";
 export declare class DalleImageGenerator implements IImageGenerator {
     private maxRetryCount;
     private azureOpenaAiBase?;
@@ -6,5 +6,5 @@ export declare class DalleImageGenerator implements IImageGenerator {
     private azureDalleDeployment?;
     private openAiKey?;
     constructor(azureOpenaAiBase: string | undefined, azureOpenAiApiKey: string | undefined, azureDalleDeployment: string | undefined, openAiKey: string | undefined);
-    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes): Promise<string | undefined>;
+    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes, options?: YpImageGenerationOptions): Promise<string | undefined>;
 }

package/services/llms/imageGeneration/dalleImageGenerator.js

@@ -1,5 +1,7 @@
 import { AzureOpenAI, OpenAI } from "openai";
 import log from "../../../utils/loggerTs.js";
+import imageModelConfig from "./imageModelConfig.cjs";
+const { getDefaultImageQualityForOptions, getDefaultImageSizeForOptions, } = imageModelConfig;
 export class DalleImageGenerator {
     constructor(azureOpenaAiBase, azureOpenAiApiKey, azureDalleDeployment, openAiKey) {
         this.maxRetryCount = 3;
@@ -8,17 +10,30 @@ export class DalleImageGenerator {
         this.azureDalleDeployment = azureDalleDeployment;
         this.openAiKey = openAiKey;
     }
-    async generateImageUrl(prompt, type = "logo") {
+    async generateImageUrl(prompt, type = "logo", options) {
         let client;
         let result;
         let retryCount = 0;
         let retrying = true;
+        const hasAzureOpenAiConfig = Boolean(this.azureOpenaAiBase &&
+            this.azureOpenAiApiKey &&
+            this.azureDalleDeployment);
+        const useAzureOpenAi = options?.imageProvider === "azureOpenai" ||
+            (!options?.imageProvider && hasAzureOpenAiConfig);
+        const requestedModel = options?.imageModel ||
+            (useAzureOpenAi ? this.azureDalleDeployment : undefined) ||
+            "dall-e-3";
+        const imageProvider = useAzureOpenAi ? "azureOpenai" : "openai";
         // Decide which client to instantiate (Azure vs. standard OpenAI)
-        if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+        if (useAzureOpenAi) {
+            if (!this.azureOpenaAiBase || !this.azureOpenAiApiKey) {
+                log.error("Azure OpenAI image generator is not configured.");
+                return undefined;
+            }
             client = new AzureOpenAI({
                 apiKey: this.azureOpenAiApiKey,
                 endpoint: this.azureOpenaAiBase,
-                deployment: this.azureDalleDeployment,
+                deployment: requestedModel,
                 apiVersion: "2024-10-21",
             });
         }
@@ -28,33 +43,30 @@ export class DalleImageGenerator {
                 apiKey: this.openAiKey,
             });
         }
-        // Decide on image dimensions
-        let size = "1792x1024";
-        if (type === "logo") {
-            size = "1792x1024";
-        }
-        else if (type === "icon") {
-            size = "1024x1024";
-        }
-        const modelQuality = "standard";
+        const size = options?.imageSize ||
+            getDefaultImageSizeForOptions(imageProvider, requestedModel, type) ||
+            "1792x1024";
+        const modelQuality = options?.imageQuality ||
+            getDefaultImageQualityForOptions(imageProvider, requestedModel) ||
+            "standard";
         while (retrying && retryCount < this.maxRetryCount) {
             try {
                 // If using Azure OpenAI
-                if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+                if (useAzureOpenAi) {
                     result = await client.images.generate({
                         prompt,
                         n: 1,
-                        size,
+                        size: size,
                         quality: modelQuality,
                     });
                 }
                 else {
                     // Standard OpenAI
                     result = await client.images.generate({
-                        model: "dall-e-3",
+                        model: requestedModel,
                         prompt,
                         n: 1,
-                        size,
+                        size: size,
                         quality: modelQuality,
                     });
                 }

package/services/llms/imageGeneration/fluxImageGenerator.d.ts

@@ -1,9 +1,9 @@
-import { IImageGenerator, YpAiGenerateImageTypes } from "./iImageGenerator.js";
+import { IImageGenerator, YpAiGenerateImageTypes, YpImageGenerationOptions } from "./iImageGenerator.js";
 export declare class FluxImageGenerator implements IImageGenerator {
     private replicateApiKey;
     private fluxProModelName;
     private replicate;
     private maxRetryCount;
     constructor(replicateApiKey: string, fluxProModelName: string);
-    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes): Promise<string | undefined>;
+    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes, options?: YpImageGenerationOptions): Promise<string | undefined>;
 }