@yrpri/api 9.0.230 → 9.0.232

package/services/llms/imageGeneration/imageModelConfig.cjs

@@ -0,0 +1,319 @@
+"use strict";
+const defaultOpenAiImageModel = "gpt-image-2";
+const defaultImagenImageModel = "imagen-4.0-generate-001";
+const defaultGptImage2LandscapeSize = "2048x1152";
+const defaultAoiIconProfileName = "aoiIcon";
+const defaultRegularAiImageProfileName = "regularAiImage";
+const imageProviders = ["openai", "azureOpenai", "flux", "imagen"];
+const openAiGptImageModels = [
+    "gpt-image-2",
+    "gpt-image-1.5",
+    "gpt-image-1",
+    "gpt-image-1-mini",
+];
+const openAiDalleImageModels = ["dall-e-3"];
+const openAiGptImageQualities = ["auto", "low", "medium", "high"];
+const openAiDalleImageQualities = ["standard", "hd"];
+const openAiLegacyGptImageSizes = [
+    "auto",
+    "1024x1024",
+    "1536x1024",
+    "1024x1536",
+];
+const openAiDalleImageSizes = ["1024x1024", "1792x1024", "1024x1792"];
+const imagenImageModels = [
+    "imagen-4.0-generate-001",
+    "imagen-4.0-fast-generate-001",
+    "imagen-4.0-ultra-generate-001",
+    "imagen-3.0-generate-002",
+    "imagen-3.0-generate-001",
+    "imagen-3.0-fast-generate-001",
+];
+const imagenAspectRatios = ["1:1", "3:4", "4:3", "9:16", "16:9"];
+const imagenResolutionAspectRatios = {
+    "1024x1024": "1:1",
+    "2048x2048": "1:1",
+    "896x1280": "3:4",
+    "1792x2560": "3:4",
+    "1280x896": "4:3",
+    "2560x1792": "4:3",
+    "768x1408": "9:16",
+    "1536x2816": "9:16",
+    "1408x768": "16:9",
+    "2816x1536": "16:9",
+};
+const supportedAspectRatioSizes = [
+    "1:1",
+    "16:9",
+    "9:16",
+    "4:3",
+    "3:4",
+    "3:2",
+    "2:3",
+    "4:5",
+    "5:4",
+    "21:9",
+    "9:21",
+];
+const imageGenerationProfiles = {
+    [defaultAoiIconProfileName]: {
+        imageProvider: "openai",
+        imageModel: "gpt-image-2",
+        imageSize: "1024x1024",
+        imageQuality: "low",
+        imageType: "icon",
+        generationContexts: ["aoiIconPublic", "aoiIconAdmin"],
+    },
+    [defaultRegularAiImageProfileName]: {
+        imageProvider: "openai",
+        imageModel: "gpt-image-2",
+        imageSize: defaultGptImage2LandscapeSize,
+        imageQuality: "medium",
+        imageType: "logo",
+        generationContexts: ["regularAiImage"],
+    },
+};
+const uniqueDefined = (values) => [...new Set(values.filter(Boolean))];
+const parsePixelSize = (imageSize) => {
+    const match = /^(\d+)x(\d+)$/.exec(imageSize || "");
+    if (!match)
+        return undefined;
+    return {
+        width: Number(match[1]),
+        height: Number(match[2]),
+    };
+};
+const greatestCommonDivisor = (a, b) => b === 0 ? a : greatestCommonDivisor(b, a % b);
+const getAspectRatioForImageSize = (imageSize) => {
+    if (!imageSize)
+        return undefined;
+    if (imagenResolutionAspectRatios[imageSize]) {
+        return imagenResolutionAspectRatios[imageSize];
+    }
+    if (supportedAspectRatioSizes.includes(imageSize))
+        return imageSize;
+    const parsedSize = parsePixelSize(imageSize);
+    if (!parsedSize)
+        return undefined;
+    const divisor = greatestCommonDivisor(parsedSize.width, parsedSize.height);
+    return `${parsedSize.width / divisor}:${parsedSize.height / divisor}`;
+};
+const isValidGptImage2Size = (imageSize) => {
+    if (imageSize === "auto")
+        return true;
+    const parsedSize = parsePixelSize(imageSize);
+    if (!parsedSize)
+        return false;
+    const { width, height } = parsedSize;
+    const longEdge = Math.max(width, height);
+    const shortEdge = Math.min(width, height);
+    const totalPixels = width * height;
+    return (width > 0 &&
+        height > 0 &&
+        longEdge <= 3840 &&
+        width % 16 === 0 &&
+        height % 16 === 0 &&
+        longEdge / shortEdge <= 3 &&
+        totalPixels >= 655360 &&
+        totalPixels <= 8294400);
+};
+const isValidAspectRatioSize = (imageSize) => supportedAspectRatioSizes.includes(imageSize) || Boolean(parsePixelSize(imageSize));
+const isValidImagenImageSize = (imageSize) => {
+    const aspectRatio = getAspectRatioForImageSize(imageSize);
+    return Boolean(aspectRatio && imagenAspectRatios.includes(aspectRatio));
+};
+const getAllowedImageModels = (imageProvider) => {
+    switch (imageProvider) {
+        case "openai":
+            return [...openAiGptImageModels, ...openAiDalleImageModels];
+        case "azureOpenai":
+            return uniqueDefined([process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME]);
+        case "flux":
+            return uniqueDefined([process.env.FLUX_PRO_MODEL_NAME]);
+        case "imagen":
+            return imagenImageModels;
+        default:
+            return [];
+    }
+};
+const getDefaultImageModelForProvider = (imageProvider) => {
+    switch (imageProvider) {
+        case "openai":
+            return defaultOpenAiImageModel;
+        case "azureOpenai":
+            return process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME;
+        case "flux":
+            return process.env.FLUX_PRO_MODEL_NAME;
+        case "imagen":
+            return defaultImagenImageModel;
+        default:
+            return undefined;
+    }
+};
+const getDefaultImageSizeForOptions = (imageProvider, imageModel, imageType) => {
+    if (imageProvider === "openai" && imageModel === "gpt-image-2") {
+        return imageType === "icon" ? "1024x1024" : defaultGptImage2LandscapeSize;
+    }
+    if (imageProvider === "openai" && openAiGptImageModels.includes(imageModel)) {
+        return imageType === "icon" ? "1024x1024" : "1536x1024";
+    }
+    if ((imageProvider === "openai" && openAiDalleImageModels.includes(imageModel)) ||
+        imageProvider === "azureOpenai") {
+        return imageType === "icon" ? "1024x1024" : "1792x1024";
+    }
+    return undefined;
+};
+const getDefaultImageQualityForOptions = (imageProvider, imageModel) => {
+    if (imageProvider === "openai" && openAiGptImageModels.includes(imageModel)) {
+        return "medium";
+    }
+    if ((imageProvider === "openai" && openAiDalleImageModels.includes(imageModel)) ||
+        imageProvider === "azureOpenai") {
+        return "standard";
+    }
+    return undefined;
+};
+const validateImageSize = (imageProvider, imageModel, imageSize) => {
+    if (!imageSize)
+        return undefined;
+    if (imageProvider === "openai" && imageModel === "gpt-image-2") {
+        return isValidGptImage2Size(imageSize)
+            ? undefined
+            : `Unsupported image size for ${imageModel}: ${imageSize}`;
+    }
+    if (imageProvider === "openai" && openAiGptImageModels.includes(imageModel)) {
+        return openAiLegacyGptImageSizes.includes(imageSize)
+            ? undefined
+            : `Unsupported image size for ${imageModel}: ${imageSize}`;
+    }
+    if ((imageProvider === "openai" && openAiDalleImageModels.includes(imageModel)) ||
+        imageProvider === "azureOpenai") {
+        return openAiDalleImageSizes.includes(imageSize)
+            ? undefined
+            : `Unsupported image size for ${imageModel}: ${imageSize}`;
+    }
+    if (imageProvider === "flux" || imageProvider === "imagen") {
+        const isValidSize = imageProvider === "imagen"
+            ? isValidImagenImageSize(imageSize)
+            : isValidAspectRatioSize(imageSize);
+        return isValidSize
+            ? undefined
+            : `Unsupported image size for ${imageProvider}: ${imageSize}`;
+    }
+    return undefined;
+};
+const validateImageQuality = (imageProvider, imageModel, imageQuality) => {
+    if (!imageQuality)
+        return undefined;
+    if (imageProvider === "openai" && openAiGptImageModels.includes(imageModel)) {
+        return openAiGptImageQualities.includes(imageQuality)
+            ? undefined
+            : `Unsupported image quality for ${imageModel}: ${imageQuality}`;
+    }
+    if ((imageProvider === "openai" && openAiDalleImageModels.includes(imageModel)) ||
+        imageProvider === "azureOpenai") {
+        return openAiDalleImageQualities.includes(imageQuality)
+            ? undefined
+            : `Unsupported image quality for ${imageModel}: ${imageQuality}`;
+    }
+    return `Image quality is not supported for ${imageProvider}`;
+};
+const normalizeImageGenerationOptions = (imageProvider, imageModel, imageSize, imageQuality) => {
+    const normalizedProvider = imageProvider || "openai";
+    if (!imageProviders.includes(normalizedProvider)) {
+        return {
+            error: `Unsupported image provider: ${normalizedProvider}`,
+        };
+    }
+    const normalizedModel = imageModel || getDefaultImageModelForProvider(normalizedProvider);
+    if (!normalizedModel) {
+        return {
+            error: `No image model is configured for provider: ${normalizedProvider}`,
+        };
+    }
+    const allowedModels = getAllowedImageModels(normalizedProvider);
+    if (!allowedModels.includes(normalizedModel)) {
+        return {
+            error: `Unsupported image model for ${normalizedProvider}: ${normalizedModel}`,
+        };
+    }
+    const imageSizeError = validateImageSize(normalizedProvider, normalizedModel, imageSize);
+    if (imageSizeError) {
+        return { error: imageSizeError };
+    }
+    const imageQualityError = validateImageQuality(normalizedProvider, normalizedModel, imageQuality);
+    if (imageQualityError) {
+        return { error: imageQualityError };
+    }
+    return {
+        imageProvider: normalizedProvider,
+        imageModel: normalizedModel,
+        ...(imageSize ? { imageSize } : {}),
+        ...(imageQuality ? { imageQuality } : {}),
+    };
+};
+const getDefaultImageGenerationProfileName = (generationContext) => {
+    switch (generationContext) {
+        case "aoiIconPublic":
+        case "aoiIconAdmin":
+            return defaultAoiIconProfileName;
+        case "regularAiImage":
+            return defaultRegularAiImageProfileName;
+        default:
+            return undefined;
+    }
+};
+const normalizeImageGenerationProfileOptions = (imageGenerationProfile, generationContext, imageType) => {
+    const profileName = imageGenerationProfile || getDefaultImageGenerationProfileName(generationContext);
+    const profile = imageGenerationProfiles[profileName];
+    if (!profile) {
+        return {
+            error: `Unsupported image generation profile: ${profileName}`,
+        };
+    }
+    if (!profile.generationContexts.includes(generationContext)) {
+        return {
+            error: `Image generation profile ${profileName} is not allowed for ${generationContext}`,
+        };
+    }
+    if (imageType && imageType !== profile.imageType) {
+        return {
+            error: `Image generation profile ${profileName} only supports ${profile.imageType} images`,
+        };
+    }
+    const options = normalizeImageGenerationOptions(profile.imageProvider, profile.imageModel, profile.imageSize, profile.imageQuality);
+    if (options.error)
+        return options;
+    return {
+        ...options,
+        imageGenerationProfile: profileName,
+    };
+};
+module.exports = {
+    defaultOpenAiImageModel,
+    defaultImagenImageModel,
+    defaultGptImage2LandscapeSize,
+    defaultAoiIconProfileName,
+    defaultRegularAiImageProfileName,
+    imageProviders,
+    imageGenerationProfiles,
+    openAiGptImageModels,
+    openAiDalleImageModels,
+    imagenImageModels,
+    imagenAspectRatios,
+    imagenResolutionAspectRatios,
+    openAiGptImageQualities,
+    openAiDalleImageQualities,
+    openAiLegacyGptImageSizes,
+    openAiDalleImageSizes,
+    getAspectRatioForImageSize,
+    getAllowedImageModels,
+    getDefaultImageGenerationProfileName,
+    getDefaultImageModelForProvider,
+    getDefaultImageSizeForOptions,
+    getDefaultImageQualityForOptions,
+    isOpenAiGptImageModel: (imageModel) => openAiGptImageModels.includes(imageModel),
+    isOpenAiDalleImageModel: (imageModel) => openAiDalleImageModels.includes(imageModel),
+    normalizeImageGenerationOptions,
+    normalizeImageGenerationProfileOptions,
+};

package/services/llms/imageGeneration/imageModelConfig.d.cts

@@ -0,0 +1,79 @@
+export const defaultOpenAiImageModel: "gpt-image-2";
+export const defaultImagenImageModel: "imagen-4.0-generate-001";
+export const defaultGptImage2LandscapeSize: "2048x1152";
+export const defaultAoiIconProfileName: "aoiIcon";
+export const defaultRegularAiImageProfileName: "regularAiImage";
+export const imageProviders: string[];
+export namespace imageGenerationProfiles {
+    namespace aoiIcon {
+        let imageProvider: string;
+        let imageModel: string;
+        let imageSize: string;
+        let imageQuality: string;
+        let imageType: string;
+        let generationContexts: string[];
+    }
+    namespace regularAiImage {
+        let imageProvider_1: string;
+        export { imageProvider_1 as imageProvider };
+        let imageModel_1: string;
+        export { imageModel_1 as imageModel };
+        export { defaultGptImage2LandscapeSize as imageSize };
+        let imageQuality_1: string;
+        export { imageQuality_1 as imageQuality };
+        let imageType_1: string;
+        export { imageType_1 as imageType };
+        let generationContexts_1: string[];
+        export { generationContexts_1 as generationContexts };
+    }
+}
+export const openAiGptImageModels: string[];
+export const openAiDalleImageModels: string[];
+export const imagenImageModels: string[];
+export const imagenAspectRatios: string[];
+export const imagenResolutionAspectRatios: {
+    "1024x1024": string;
+    "2048x2048": string;
+    "896x1280": string;
+    "1792x2560": string;
+    "1280x896": string;
+    "2560x1792": string;
+    "768x1408": string;
+    "1536x2816": string;
+    "1408x768": string;
+    "2816x1536": string;
+};
+export const openAiGptImageQualities: string[];
+export const openAiDalleImageQualities: string[];
+export const openAiLegacyGptImageSizes: string[];
+export const openAiDalleImageSizes: string[];
+export function getAspectRatioForImageSize(imageSize: any): any;
+export function getAllowedImageModels(imageProvider: any): any[];
+export function getDefaultImageGenerationProfileName(generationContext: any): "aoiIcon" | "regularAiImage" | undefined;
+export function getDefaultImageModelForProvider(imageProvider: any): string | undefined;
+export function getDefaultImageSizeForOptions(imageProvider: any, imageModel: any, imageType: any): "2048x1152" | "1024x1024" | "1536x1024" | "1792x1024" | undefined;
+export function getDefaultImageQualityForOptions(imageProvider: any, imageModel: any): "medium" | "standard" | undefined;
+export function normalizeImageGenerationOptions(imageProvider: any, imageModel: any, imageSize: any, imageQuality: any): {
+    error: string;
+} | {
+    imageQuality?: any;
+    imageSize?: any;
+    imageProvider: any;
+    imageModel: any;
+    error?: undefined;
+};
+export function normalizeImageGenerationProfileOptions(imageGenerationProfile: any, generationContext: any, imageType: any): {
+    error: string;
+} | {
+    imageGenerationProfile: any;
+    error: string;
+} | {
+    imageGenerationProfile: any;
+    imageQuality?: any;
+    imageSize?: any;
+    imageProvider: any;
+    imageModel: any;
+    error?: undefined;
+};
+export declare function isOpenAiGptImageModel(imageModel: any): boolean;
+export declare function isOpenAiDalleImageModel(imageModel: any): boolean;

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

@@ -1,16 +1,15 @@
-import { IImageGenerator, YpAiGenerateImageTypes } from "./iImageGenerator.js";
+import { IImageGenerator, YpAiGenerateImageTypes, YpImageGenerationOptions } from "./iImageGenerator.js";
 import { S3Service } from "./s3Service.js";
 export declare class ImagenImageGenerator implements IImageGenerator {
     private s3Service;
     private maxRetryCount;
     private projectId;
     private location;
-    private endpoint;
     private s3Bucket;
     constructor(s3Service: S3Service);
     /**
      * Generates an image from a text prompt using Vertex AI Imagen
      * and returns a public S3 URL to the uploaded image.
      */
-    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes): Promise<string | undefined>;
+    generateImageUrl(prompt: string, type?: YpAiGenerateImageTypes, options?: YpImageGenerationOptions): Promise<string | undefined>;
 }

package/services/llms/imageGeneration/imagenImageGenerator.js

@@ -4,6 +4,8 @@ import { v4 as uuidv4 } from "uuid";
 import { PredictionServiceClient } from "@google-cloud/aiplatform";
 import { helpers } from "@google-cloud/aiplatform";
 import log from "../../../utils/loggerTs.js";
+import imageModelConfig from "./imageModelConfig.cjs";
+const { defaultImagenImageModel, getAspectRatioForImageSize } = imageModelConfig;
 export class ImagenImageGenerator {
     constructor(s3Service) {
         this.s3Service = s3Service;
@@ -11,8 +13,6 @@ export class ImagenImageGenerator {
         // 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) {
             log.warn("Warning: GOOGLE_CLOUD_PROJECT_ID is not set. Vertex AI calls may fail.");
@@ -25,9 +25,11 @@ export class ImagenImageGenerator {
      * 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") {
+    async generateImageUrl(prompt, type = "logo", options) {
         let retryCount = 0;
         let finalUrl;
+        const imageModel = options?.imageModel || defaultImagenImageModel;
+        const endpoint = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/${imageModel}`;
         // Configure the API endpoint for Vertex AI
         const clientOptions = {
             apiEndpoint: `${this.location}-aiplatform.googleapis.com`,
@@ -43,17 +45,15 @@ export class ImagenImageGenerator {
                 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",
+                    aspectRatio: options?.imageSize
+                        ? getAspectRatioForImageSize(options.imageSize)
+                        : "16:9",
+                    safetySetting: "block_medium_and_above",
                 };
                 const parameters = helpers.toValue(parameter);
                 // 2) Build the predict request
                 const request = {
-                    endpoint: this.endpoint,
+                    endpoint,
                     instances,
                     parameters,
                 };