@yrpri/api 9.0.103 → 9.0.105

package/dist/agents/managers/newAiModelSetup.js

@@ -1,650 +0,0 @@
-import { sequelize as psSequelize } from "@policysynth/agents/dbModels/index.js";
-import { PsAiModel } from "@policysynth/agents/dbModels/aiModel.js";
-import { PsAgentClass } from "@policysynth/agents/dbModels/agentClass.js";
-import { PsAgentClassCategories } from "@policysynth/agents/agentCategories.js";
-import { PsExternalApiUsage } from "@policysynth/agents/dbModels/externalApiUsage.js";
-import { PsExternalApi } from "@policysynth/agents/dbModels/externalApis.js";
-import { PsModelUsage } from "@policysynth/agents/dbModels/modelUsage.js";
-import { PsAgent } from "@policysynth/agents/dbModels/agent.js";
-import { PsAgentAuditLog } from "@policysynth/agents/dbModels/agentAuditLog.js";
-import { PsAgentConnector } from "@policysynth/agents/dbModels/agentConnector.js";
-import { PsAgentConnectorClass } from "@policysynth/agents/dbModels/agentConnectorClass.js";
-import { PsAgentRegistry } from "@policysynth/agents/dbModels/agentRegistry.js";
-import { PsAiModelSize, PsAiModelType, } from "@policysynth/agents/aiModelTypes.js";
-import models from "../../models/index.cjs";
-const dbModels = models;
-const Group = dbModels.Group; // for reference elsewhere if needed
-// List of models that need to be initialized/associated
-const psModels = {
-    PsAgentClass,
-    PsExternalApiUsage,
-    PsModelUsage,
-    PsAgentConnector,
-    PsAgent,
-    PsAgentAuditLog,
-    PsAgentConnectorClass,
-    PsAgentRegistry,
-    PsAiModel,
-    PsExternalApi,
-};
-export class NewAiModelSetup {
-    /**
-     * Initializes all models by calling their associate methods (if present).
-     */
-    static async initializeModels() {
-        try {
-            console.log("All Models Loaded Init");
-            for (const modelName of Object.keys(psModels)) {
-                if (typeof psModels[modelName].associate === "function") {
-                    await psModels[modelName].associate(psSequelize.models);
-                }
-            }
-            if (process.env.FORCE_DB_SYNC || process.env.NODE_ENV === "development") {
-                await psSequelize.sync();
-            }
-            console.log("All models initialized successfully.");
-        }
-        catch (error) {
-            console.error("Error initializing models:", error);
-            process.exit(1);
-        }
-    }
-    /**
-     * Seeds the test AI models (and a top-level agent class) if they do not exist.
-     * @param userId the user id to associate with the new models
-     */
-    static async seedAnthropicModels(userId) {
-        const anthropicSonnet = await PsAiModel.findOne({
-            where: { name: "Anthropic Sonnet 3.5" },
-        });
-        if (!anthropicSonnet) {
-            const anthropicSonnetConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Medium,
-                provider: "anthropic",
-                prices: {
-                    costInTokensPerMillion: 3,
-                    costOutTokensPerMillion: 15,
-                    currency: "USD",
-                },
-                maxTokensOut: 8000,
-                defaultTemperature: 0.7,
-                model: "claude-3-5-sonnet-20240620",
-                active: true,
-            };
-            const createdModel = await PsAiModel.create({
-                name: "Anthropic Sonnet 3.5",
-                organization_id: 1,
-                user_id: userId,
-                configuration: anthropicSonnetConfig,
-            });
-            console.log("Created Anthropic model:", createdModel);
-        }
-        else {
-            console.log("Anthropic model already exists: Anthropic Sonnet 3.5");
-        }
-    }
-    static async seedAnthropic37Models(userId) {
-        const anthropicSonnet = await PsAiModel.findOne({
-            where: { name: "Anthropic Sonnet 3.7" },
-        });
-        const anthropicSonnetConfig = {
-            type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Medium,
-            provider: "anthropic",
-            prices: {
-                costInTokensPerMillion: 3,
-                costOutTokensPerMillion: 15,
-                currency: "USD",
-            },
-            maxTokensOut: 8000,
-            defaultTemperature: 0.7,
-            model: "claude-3-7-sonnet-20250219",
-            active: true,
-        };
-        if (!anthropicSonnet) {
-            const createdModel = await PsAiModel.create({
-                name: "Anthropic Sonnet 3.7",
-                organization_id: 1,
-                user_id: userId,
-                configuration: anthropicSonnetConfig,
-            });
-            console.log("Created Anthropic model:", createdModel);
-        }
-        else {
-            console.log("Anthropic model already exists: Anthropic Sonnet 3.7");
-        }
-    }
-    /**
-     * Seeds OpenAI models.
-     * This currently creates several models including GPT-4o, GPT-4o Mini, o1 Mini,
-     * o1 Preview, o1 24, and o3 mini.
-     */
-    static async seedOpenAiModels(userId) {
-        // GPT-4o
-        const openAiGpt4 = await PsAiModel.findOne({
-            where: { name: "GPT-4o" },
-        });
-        const openAiGpt4oConfig = {
-            type: PsAiModelType.Text,
-            modelSize: PsAiModelSize.Medium,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 2.5,
-                costOutTokensPerMillion: 10,
-                currency: "USD",
-            },
-            maxTokensOut: 16384,
-            defaultTemperature: 0.7,
-            model: "gpt-4o",
-            active: true,
-        };
-        if (!openAiGpt4) {
-            await PsAiModel.create({
-                name: "GPT-4o",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt4oConfig,
-            });
-            console.log("Created OpenAI model: GPT-4o");
-        }
-        else {
-            console.log("OpenAI model already exists: GPT-4o updating");
-            openAiGpt4.set("configuration", openAiGpt4oConfig);
-            openAiGpt4.changed("configuration", true);
-            await openAiGpt4.save();
-        }
-        // GPT-4o Mini
-        const openAiGpt4Mini = await PsAiModel.findOne({
-            where: { name: "GPT-4o Mini" },
-        });
-        if (!openAiGpt4Mini) {
-            const openAiGpt4oMiniConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Small,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 0.15,
-                    costOutTokensPerMillion: 0.6,
-                    currency: "USD",
-                },
-                maxTokensOut: 16384,
-                defaultTemperature: 0.0,
-                model: "gpt-4o-mini",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "GPT-4o Mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt4oMiniConfig,
-            });
-            console.log("Created OpenAI model: GPT-4o Mini");
-        }
-        else {
-            console.log("OpenAI model already exists: GPT-4o Mini");
-        }
-        // o1 Mini
-        const openAio1Mini = await PsAiModel.findOne({
-            where: { name: "o1 Mini" },
-        });
-        if (!openAio1Mini) {
-            const openAio1MiniConfig = {
-                type: PsAiModelType.TextReasoning,
-                modelSize: PsAiModelSize.Small,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 3.0,
-                    costOutTokensPerMillion: 12.0,
-                    currency: "USD",
-                },
-                maxTokensOut: 32000,
-                defaultTemperature: 0.0,
-                model: "o1-mini",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "o1 Mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio1MiniConfig,
-            });
-            console.log("Created OpenAI model: o1 Mini");
-        }
-        else {
-            console.log("OpenAI model already exists: o1 Mini");
-        }
-        // o1 Preview
-        const openAio1Preview = await PsAiModel.findOne({
-            where: { name: "o1 Preview" },
-        });
-        if (!openAio1Preview) {
-            const openAio1PreviewConfig = {
-                type: PsAiModelType.TextReasoning,
-                modelSize: PsAiModelSize.Medium,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 15.0,
-                    costOutTokensPerMillion: 60.0,
-                    currency: "USD",
-                },
-                maxTokensOut: 32000,
-                defaultTemperature: 0.0,
-                model: "o1-preview",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "o1 Preview",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio1PreviewConfig,
-            });
-            console.log("Created OpenAI model: o1 Preview");
-        }
-        else {
-            console.log("OpenAI model already exists: o1 Preview");
-        }
-        // o1 24
-        const openAio11712 = await PsAiModel.findOne({
-            where: { name: "o1 24" },
-        });
-        const openAio11712Config = {
-            type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Medium,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 15.0,
-                costOutTokensPerMillion: 60.0,
-                currency: "USD",
-            },
-            maxTokensOut: 100000,
-            defaultTemperature: 0.0,
-            model: "o1",
-            active: true,
-        };
-        if (!openAio11712) {
-            await PsAiModel.create({
-                name: "o1 24",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio11712Config,
-            });
-            console.log("Created OpenAI model: o1 24");
-        }
-        else {
-            console.log("OpenAI model already exists: o1 24 updating");
-            openAio11712.set("configuration", openAio11712Config);
-            openAio11712.changed("configuration", true);
-            await openAio11712.save();
-        }
-        // o3 mini
-        const openAio3Mini = await PsAiModel.findOne({
-            where: { name: "o3 mini" },
-        });
-        if (!openAio3Mini) {
-            const openAio3MiniConfig = {
-                type: PsAiModelType.TextReasoning,
-                modelSize: PsAiModelSize.Small,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 1.1,
-                    costOutTokensPerMillion: 4.4,
-                    currency: "USD",
-                },
-                maxTokensOut: 100000,
-                defaultTemperature: 0.0,
-                model: "o3-mini",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "o3 mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio3MiniConfig,
-            });
-            console.log("Created OpenAI model: o3 mini");
-        }
-        else {
-            console.log("OpenAI model already exists: o3 mini");
-        }
-        const openAiGpt45 = await PsAiModel.findOne({
-            where: { name: "GPT-4.5 Preview" },
-        });
-        const openAiGpt45Config = {
-            type: PsAiModelType.Text,
-            modelSize: PsAiModelSize.Large,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 75,
-                costOutTokensPerMillion: 150,
-                currency: "USD",
-            },
-            maxTokensOut: 100000,
-            defaultTemperature: 0.7,
-            model: "gpt-4.5-preview",
-            active: true,
-        };
-        if (!openAiGpt45) {
-            await PsAiModel.create({
-                name: "GPT-4.5 Preview",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt45Config,
-            });
-            console.log("Created OpenAI model: GPT-4.5 Preview");
-        }
-        else {
-            console.log("OpenAI model already exists: GPT-4.5 Preview updating");
-        }
-        const openAio3 = await PsAiModel.findOne({
-            where: { name: "o3" },
-        });
-        const openAio3Config = {
-            type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Medium,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 10.0,
-                costOutTokensPerMillion: 40.0,
-                cacheCostInTokensPerMillion: 2.5,
-                currency: "USD",
-            },
-            maxTokensOut: 100000,
-            defaultTemperature: 0.0,
-            model: "o3",
-            active: true,
-        };
-        if (!openAio3) {
-            await PsAiModel.create({
-                name: "o3",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio3Config,
-            });
-            console.log("Created OpenAI model: o3");
-        }
-        else {
-            console.log("OpenAI model already exists: o3 updating");
-            openAio3.set("configuration", openAio3Config);
-            openAio3.changed("configuration", true);
-            await openAio3.save();
-        }
-        const openAio4mini = await PsAiModel.findOne({
-            where: { name: "o4 mini" },
-        });
-        const openAio4miniConfig = {
-            type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Small,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 1.1,
-                costOutTokensPerMillion: 4.4,
-                cacheCostInTokensPerMillion: 0.275,
-                currency: "USD",
-            },
-            maxTokensOut: 100000,
-            defaultTemperature: 0.0,
-            model: "o4-mini",
-            active: true,
-        };
-        if (!openAio4mini) {
-            await PsAiModel.create({
-                name: "o4 mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio4miniConfig,
-            });
-            console.log("Created OpenAI model: o4 mini");
-        }
-        else {
-            console.log("OpenAI model already exists: o4 mini");
-        }
-        const openAiGpt41 = await PsAiModel.findOne({
-            where: { name: "GPT-4.1" },
-        });
-        const openAiGpt41Config = {
-            type: PsAiModelType.Text,
-            modelSize: PsAiModelSize.Medium,
-            provider: "openai",
-            prices: {
-                costInTokensPerMillion: 2,
-                costOutTokensPerMillion: 8,
-                currency: "USD",
-                cacheCostInTokensPerMillion: 0.5
-            },
-            maxTokensOut: 100000,
-            defaultTemperature: 0.7,
-            model: "gpt-4.1",
-            active: true,
-        };
-        if (!openAiGpt41) {
-            await PsAiModel.create({
-                name: "GPT-4.1",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt41Config,
-            });
-            console.log("Created OpenAI model: GPT-4.1");
-        }
-        else {
-            console.log("OpenAI model already exists: GPT-4.1");
-        }
-    }
-    /**
-     * Seeds Google models.
-     * Currently, this creates Gemini 1.5 Pro 2 and Gemini 1.5 Flash 2.
-     */
-    static async seedGoogleModels(userId) {
-        // Gemini 1.5 Pro 2
-        const geminiPro = await PsAiModel.findOne({
-            where: { name: "Gemini 1.5 Pro 2" },
-        });
-        if (!geminiPro) {
-            const geminiProConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Medium,
-                provider: "google",
-                prices: {
-                    costInTokensPerMillion: 1.25,
-                    costOutTokensPerMillion: 5.0,
-                    currency: "USD",
-                },
-                maxTokensOut: 8192,
-                defaultTemperature: 0.0,
-                model: "gemini-1.5-pro-002",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "Gemini 1.5 Pro 2",
-                organization_id: 1,
-                user_id: userId,
-                configuration: geminiProConfig,
-            });
-            console.log("Created Google model: Gemini 1.5 Pro 2");
-        }
-        else {
-            console.log("Google model already exists: Gemini 1.5 Pro 2");
-        }
-        // Gemini 1.5 Flash 2
-        const geminiPro15Flash = await PsAiModel.findOne({
-            where: { name: "Gemini 1.5 Flash 2" },
-        });
-        if (!geminiPro15Flash) {
-            const geminiPro15FlashConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Small,
-                provider: "google",
-                prices: {
-                    costInTokensPerMillion: 0.075,
-                    costOutTokensPerMillion: 0.3,
-                    currency: "USD",
-                },
-                maxTokensOut: 8192,
-                defaultTemperature: 0.0,
-                model: "gemini-1.5-flash-002",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "Gemini 1.5 Flash 2",
-                organization_id: 1,
-                user_id: userId,
-                configuration: geminiPro15FlashConfig,
-            });
-            console.log("Created Google model: Gemini 1.5 Flash 2");
-        }
-        else {
-            console.log("Google model already exists: Gemini 1.5 Flash 2");
-        }
-        // Gemini 2.0 Flash
-        const gemini20Flash = await PsAiModel.findOne({
-            where: { name: "Gemini 2.0 Flash" },
-        });
-        if (!gemini20Flash) {
-            const gemini20FlashConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Medium,
-                provider: "google",
-                prices: {
-                    costInTokensPerMillion: 0.1,
-                    costOutTokensPerMillion: 0.4,
-                    currency: "USD",
-                },
-                maxTokensOut: 8192,
-                defaultTemperature: 0.0,
-                model: "gemini-2.0-flash",
-                active: true,
-            };
-            await PsAiModel.create({
-                name: "Gemini 2.0 Flash",
-                organization_id: 1,
-                user_id: userId,
-                configuration: gemini20FlashConfig,
-            });
-            console.log("Created Google model: Gemini 2.0 Flash");
-        }
-        else {
-            console.log("Google model already exists: Gemini 2.0 Flash");
-        }
-    }
-    /**
-     * Master seeding function which calls the provider-specific functions
-     * and also seeds a top-level agent class.
-     */
-    static async seedAiModels(userId) {
-        try {
-            await NewAiModelSetup.seedAnthropicModels(userId);
-            await NewAiModelSetup.seedAnthropic37Models(userId);
-            await NewAiModelSetup.seedOpenAiModels(userId);
-            await NewAiModelSetup.seedGoogleModels(userId);
-            // Optionally, seed the top-level agent class if it does not exist.
-            const topLevelAgentClass = await PsAgentClass.findOne({
-                where: { name: "Operations" },
-            });
-            if (!topLevelAgentClass) {
-                const topLevelAgentClassConfig = {
-                    category: PsAgentClassCategories.PolicySynthTopLevel,
-                    subCategory: "group",
-                    hasPublicAccess: true,
-                    description: "A top-level agent that coordinates other agents",
-                    queueName: "noqueue",
-                    imageUrl: "https://yrpri-eu-direct-assets.s3.eu-west-1.amazonaws.com/topLevelAgent.png",
-                    iconName: "coordinator",
-                    capabilities: [
-                        "process coordination",
-                        "task management",
-                        "result aggregation",
-                    ],
-                    questions: [],
-                    requestedAiModelSizes: [
-                        PsAiModelSize.Large,
-                        PsAiModelSize.Medium,
-                        PsAiModelSize.Small,
-                    ],
-                    supportedConnectors: [],
-                };
-                await PsAgentClass.create({
-                    class_base_id: "c375c1fb-58ca-4372-a567-0e02b2c3d479",
-                    name: "Operations",
-                    version: 1,
-                    available: true,
-                    configuration: topLevelAgentClassConfig,
-                    user_id: userId,
-                });
-                console.log("Created top-level agent class: Operations");
-            }
-            else {
-                console.log("Top-level agent class: Operations already exists");
-            }
-        }
-        catch (error) {
-            console.error("Error seeding AI models:", error);
-            process.exit(1);
-        }
-    }
-    /**
-     * Helper to delay model seeding slightly.
-     */
-    static setupAiModels(userId) {
-        setTimeout(async () => {
-            console.log("Seeding AI models");
-            await NewAiModelSetup.seedAiModels(userId);
-        }, 100);
-    }
-    /**
-     * Sets up the API keys for a given group based on the latest active AI models.
-     * @param group The group instance on which to set the API keys
-     */
-    static async setupApiKeysForGroup(group) {
-        // Helper to find the latest active model by name
-        const findLatestActiveModel = async (name) => {
-            return await PsAiModel.findOne({
-                where: {
-                    name,
-                    configuration: { active: true },
-                },
-                order: [["created_at", "DESC"]],
-            });
-        };
-        // Cache the API keys from environment variables
-        const apiKeys = {
-            ANTHROPIC_CLAUDE_API_KEY: process.env.ANTHROPIC_CLAUDE_API_KEY,
-            OPENAI_API_KEY: process.env.OPENAI_API_KEY,
-            GEMINI_API_KEY: process.env.GEMINI_API_KEY,
-        };
-        // Define a mapping between model names and their required API key
-        // Explicitly type envKey as a key of apiKeys
-        const modelsMapping = [
-            { name: "Anthropic Sonnet 3.5", envKey: "ANTHROPIC_CLAUDE_API_KEY" },
-            { name: "Anthropic Sonnet 3.7", envKey: "ANTHROPIC_CLAUDE_API_KEY" },
-            { name: "GPT-4o", envKey: "OPENAI_API_KEY" },
-            { name: "GPT-4o Mini", envKey: "OPENAI_API_KEY" },
-            { name: "GPT-4.5 Preview", envKey: "OPENAI_API_KEY" },
-            { name: "o1 Preview", envKey: "OPENAI_API_KEY" },
-            { name: "o1 Mini", envKey: "OPENAI_API_KEY" },
-            { name: "Gemini 1.5 Pro 2", envKey: "GEMINI_API_KEY" },
-            { name: "Gemini 1.5 Flash 2", envKey: "GEMINI_API_KEY" },
-            { name: "Gemini 2.0 Flash", envKey: "GEMINI_API_KEY" },
-            { name: "o1 24", envKey: "OPENAI_API_KEY" },
-            { name: "o3 mini", envKey: "OPENAI_API_KEY" },
-            { name: "o4 mini", envKey: "OPENAI_API_KEY" },
-            { name: "GPT-4.1", envKey: "OPENAI_API_KEY" },
-            { name: "o3", envKey: "OPENAI_API_KEY" },
-        ];
-        const groupAccessConfig = [];
-        for (const { name, envKey } of modelsMapping) {
-            const apiKey = apiKeys[envKey];
-            if (!apiKey)
-                continue; // Skip if the API key is not provided
-            const model = await findLatestActiveModel(name);
-            if (model) {
-                groupAccessConfig.push({
-                    aiModelId: model.id,
-                    apiKey,
-                });
-            }
-        }
-        group.set("private_access_configuration", groupAccessConfig);
-        group.changed("private_access_configuration", true);
-        await group.save();
-    }
-}