@yrpri/api 9.0.231 → 9.0.232

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>;
 }

package/services/llms/imageGeneration/fluxImageGenerator.js

@@ -1,5 +1,7 @@
 import Replicate from "replicate";
 import log from "../../../utils/loggerTs.js";
+import imageModelConfig from "./imageModelConfig.cjs";
+const { getAspectRatioForImageSize } = imageModelConfig;
 export class FluxImageGenerator {
     constructor(replicateApiKey, fluxProModelName) {
         this.replicateApiKey = replicateApiKey;
@@ -7,14 +9,17 @@ export class FluxImageGenerator {
         this.maxRetryCount = 3;
         this.replicate = new Replicate({ auth: replicateApiKey });
     }
-    async generateImageUrl(prompt, type = "logo") {
+    async generateImageUrl(prompt, type = "logo", options) {
         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") {
+        if (options?.imageSize) {
+            input.aspect_ratio = getAspectRatioForImageSize(options.imageSize);
+        }
+        else if (type === "logo") {
             input.aspect_ratio = "16:9";
         }
         else if (type === "icon") {
@@ -25,7 +30,8 @@ export class FluxImageGenerator {
         }
         while (retrying && retryCount < this.maxRetryCount) {
             try {
-                result = await this.replicate.run(this.fluxProModelName, {
+                const modelName = options?.imageModel || this.fluxProModelName;
+                result = await this.replicate.run(modelName, {
                     input,
                 });
                 if (result) {

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

@@ -1,7 +1,14 @@
 export type YpAiGenerateImageTypes = "logo" | "icon" | "other";
+export type YpAiGenerateImageProvider = "openai" | "azureOpenai" | "flux" | "imagen";
+export interface YpImageGenerationOptions {
+    imageProvider?: YpAiGenerateImageProvider;
+    imageModel?: string;
+    imageSize?: string;
+    imageQuality?: string;
+}
 export interface IImageGenerator {
     /**
      * Generates an image URL given a prompt and a type (logo, icon, etc.)
      */
-    generateImageUrl(prompt: string, type: YpAiGenerateImageTypes): Promise<string | undefined>;
+    generateImageUrl(prompt: string, type: YpAiGenerateImageTypes, options?: YpImageGenerationOptions): Promise<string | undefined>;
 }