@yrpri/api 9.0.88 → 9.0.89

package/active-citizen/engine/notifications/emails_utils.cjs

@@ -419,6 +419,9 @@ var sendOneEmail = function (emailLocals, callback) {
                     else {
                         locale = "en";
                     }
+                    if (locale && typeof locale === 'string') {
+                        locale = locale.toLowerCase();
+                    }
                     i18n.changeLanguage(locale, function (err, t) {
                         seriesCallback(err);
                     });

package/active-citizen/llms/baseChatBot.js

@@ -1,19 +1,13 @@
 import { OpenAI } from "openai";
 import { v4 as uuidv4 } from "uuid";
 import ioredis from "ioredis";
-let tlsConfig = {
-    rejectUnauthorized: false,
-};
-if (!process.env.REDIS_URL || process.env.REDIS_URL.indexOf("localhost") > -1) {
-    tlsConfig = undefined;
-}
 const DEBUG = false;
-//@ts-ignore
-const redis = new ioredis.default(process.env.REDIS_MEMORY_URL ||
+const url = process.env.REDIS_MEMORY_URL ||
     process.env.REDIS_URL ||
-    "redis://localhost:6379", {
-    tls: tlsConfig,
-});
+    "redis://localhost:6379";
+const tlsOptions = url.startsWith("rediss://")
+    ? { rejectUnauthorized: false }
+    : undefined;
 export class YpBaseChatBot {
     get redisKey() {
         return `${YpBaseChatBot.redisMemoryKeyPrefix}-${this.memoryId}`;
@@ -21,6 +15,12 @@ export class YpBaseChatBot {
     static loadMemoryFromRedis(memoryId) {
         return new Promise(async (resolve, reject) => {
             try {
+                //@ts-ignore
+                const redis = new ioredis.default(process.env.REDIS_MEMORY_URL ||
+                    process.env.REDIS_URL ||
+                    "redis://localhost:6379", {
+                    tls: tlsOptions,
+                });
                 const memoryString = await redis.get(`${YpBaseChatBot.redisMemoryKeyPrefix}-${memoryId}`);
                 if (memoryString) {
                     const memory = JSON.parse(memoryString);
@@ -42,7 +42,7 @@ export class YpBaseChatBot {
     loadMemory() {
         return new Promise(async (resolve, reject) => {
             try {
-                const memoryString = await redis.get(this.redisKey);
+                const memoryString = await this.redis.get(this.redisKey);
                 if (memoryString) {
                     const memory = JSON.parse(memoryString);
                     resolve(memory);
@@ -62,6 +62,12 @@ export class YpBaseChatBot {
         this.maxTokens = 16000;
         this.llmModel = "gpt-4o";
         this.persistMemory = false;
+        //@ts-ignore
+        this.redis = new ioredis.default(process.env.REDIS_MEMORY_URL ||
+            process.env.REDIS_URL ||
+            "redis://localhost:6379", {
+            tls: tlsOptions,
+        });
         this.wsClientId = wsClientId;
         this.wsClientSocket = wsClients.get(this.wsClientId);
         this.openaiClient = new OpenAI({
@@ -102,7 +108,7 @@ export class YpBaseChatBot {
     async saveMemory() {
         if (this.memory) {
             try {
-                await redis.set(this.redisKey, JSON.stringify(this.memory));
+                await this.redis.set(this.redisKey, JSON.stringify(this.memory));
                 console.log(`Saved memory to redis: ${this.redisKey}`);
             }
             catch (error) {

package/active-citizen/workers/queue.cjs

@@ -66,7 +66,7 @@ class YpQueue {
         }).on('completed', function (job, result) {
             log.info('JC', { id: job.id, name: job.name });
         }).on('failed', function (job, error) {
-            log.error('Job Failed', { id: job.id, name: job.name, data: job.data, error });
+            log.error('Job Failed', { id: job ? job.id : null, name: job ? job.name : null, data: job ? job.data : null, error });
         }).on('resumed', function (job) {
             log.info('Job Removed', { id: job.id });
         }).on('waiting', function (jobId) {

package/agents/assistants/baseAssistant.js

@@ -22,25 +22,30 @@ export class YpBaseAssistant extends YpBaseChatBot {
         this.toolCallTimeout = 30000; // 30 seconds
         this.maxModeTransitions = 10;
         this.modelName = "gpt-4o";
-        this.defaultSystemPrompt = `# Basic instructions
+        this.defaultSystemPrompt = `<coreImportantSystemInstructions>
 You are a helpful, witty, and friendly AI. Act like a human, but remember that you aren't a human and that you can't do human things in the real world.
 Your voice and personality should be warm and engaging, with a lively and playful tone. Talk quickly.
 If interacting in a non-English language, start by using the standard accent or dialect familiar to the user.
 You should always call a function/tool if you can to help the user with their request.
 Never try to start workflows without using functions/tools, using some tools will unlock other function/tools that might help the user with their request.
 Functions/tools will become available to you as the user progresses through the workflow.
-Make sure that the user is subscribed to the agent before you start a workflow.
+Make sure that the user logged in and is subscribed to the agent before you start a workflow.
 Never list out the available agents using text or markdown, the user already sees the list of agents available for subscription in the UI.
-You will not be able to complete the request for the user except using tools/functions at each step.
+You will not be able to start the workflow for the user except using tools/functions at each step.
+Never engage in longish back and fourth conversations with the user if a workflow has not started, lead the user towards using the tools available as much as possible, politely.
+Never engage in off topic conversations, always politely steer the conversation back to the workflow.
+</coreImportantSystemInstructions>
 
-# Typical start of a user workflow is:
+<typicalWorkflowStepsForStartingAnAgentWorkflow>
 1) The user chooses an agent to subscribe to using the direct connect to the agent the user chooses. It's only possible to subscribe to the agent after the user has connected directly to the agent.
 2) The agent offers to show the user a workflow overview, with a tool and then informs the user about the subscription process.
 3) The user logs in or creates an account, if not logged in.
 4) The user verbally confirms a subscription to the agent using a function/tool.
 5) The user fills out the configuration UI widget.
 6) The user submits from the configuration UI widget.
-7) The user starts the workflow.`;
+7) The user starts the workflow run.
+</typicalWorkflowStepsForStartingAnAgentWorkflow>
+`;
         this.voiceEnabled = false;
         this.domainId = domainId;
         if (!domainId) {
@@ -479,7 +484,7 @@ You will not be able to complete the request for the user except using tools/fun
             console.error(`No current mode found: ${this.memory.currentMode}`);
             return this.defaultSystemPrompt;
         }
-        return `${this.defaultSystemPrompt}\n\n# Current agent instructions:\n${currentMode.systemPrompt}`;
+        return `${this.defaultSystemPrompt}\n\n<furtherAgentInstructions>\n${currentMode.systemPrompt}\n</furtherAgentInstructions>`;
     }
     sendAvatarUrlChange(url, avatarName) {
         this.wsClientSocket.send(JSON.stringify({

package/agents/controllers/policySynthAgents.js

@@ -1,4 +1,3 @@
-var _a;
 import express from "express";
 import { AgentQueueManager } from "@policysynth/agents/operations/agentQueueManager.js";
 import { AgentCostManager } from "@policysynth/agents/operations/agentCostsManager.js";
@@ -8,53 +7,14 @@ import { AgentRegistryManager } from "@policysynth/agents/operations/agentRegist
 import { PsAiModel } from "@policysynth/agents/dbModels/aiModel.js";
 import auth from "../../authorization.cjs";
 import models from "../../models/index.cjs";
-import { PsAiModelSize, PsAiModelType, } from "@policysynth/agents/aiModelTypes.js";
-import { PsAgentClass } from "@policysynth/agents/dbModels/agentClass.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 { PsExternalApiUsage } from "@policysynth/agents/dbModels/externalApiUsage.js";
-import { PsExternalApi } from "@policysynth/agents/dbModels/externalApis.js";
-import { PsModelUsage } from "@policysynth/agents/dbModels/modelUsage.js";
-import { sequelize as psSequelize } from "@policysynth/agents/dbModels/index.js";
-import { PsAgentClassCategories } from "@policysynth/agents/agentCategories.js";
+import { NewAiModelSetup } from "../managers/newAiModelSetup.js";
 const dbModels = models;
 const Group = dbModels.Group;
 const User = dbModels.User;
-const psModels = {
-    PsAgentClass,
-    PsExternalApiUsage,
-    PsModelUsage,
-    PsAgentConnector,
-    PsAgent,
-    PsAgentAuditLog,
-    PsAgentConnectorClass,
-    PsAgentRegistry,
-    PsAiModel,
-    PsExternalApi,
-};
 export class PolicySynthAgentsController {
     constructor(wsClients) {
         this.path = "/api/agents";
         this.router = express.Router();
-        this.initializeModels = async () => {
-            try {
-                console.log(`All Models Loaded Init`);
-                // Call associate method to set up associations
-                for (const modelName of Object.keys(psModels)) {
-                    if (psModels[modelName].associate) {
-                        await psModels[modelName].associate(psSequelize.models);
-                    }
-                }
-                console.log("All models initialized successfully.");
-            }
-            catch (error) {
-                console.error("Error initializing models:", error);
-                process.exit(1);
-            }
-        };
         this.replaceAgentMemory = async (req, res) => {
             try {
                 const { groupId, agentId } = req.params;
@@ -69,12 +29,16 @@ export class PolicySynthAgentsController {
                 }
                 catch (jsonError) {
                     console.log(`Received invalid JSON for agent ${agentId}`);
-                    return res.status(400).json({ error: "Invalid JSON format for memory" });
+                    return res
+                        .status(400)
+                        .json({ error: "Invalid JSON format for memory" });
                 }
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res.status(404).json({ error: "Memory key not found for the specified agent" });
+                    return res
+                        .status(404)
+                        .json({ error: "Memory key not found for the specified agent" });
                 }
                 console.log(`Memory key found: ${memoryKey}`);
                 await req.redisClient.set(memoryKey, JSON.stringify(memory));
@@ -101,7 +65,9 @@ export class PolicySynthAgentsController {
             }
             try {
                 await this.agentConnectorManager.addExistingConnector(parseInt(groupId), parseInt(agentId), parseInt(connectorId), type);
-                res.status(200).json({ message: `Existing ${connectorId} connector added successfully` });
+                res.status(200).json({
+                    message: `Existing ${connectorId} connector added successfully`,
+                });
             }
             catch (error) {
                 console.error(`Error adding existing ${connectorId} connector:`, error);
@@ -117,21 +83,20 @@ export class PolicySynthAgentsController {
             try {
                 const { groupId, agentId } = req.params;
                 console.log(`Attempting to get memory for agent ${agentId} in group ${groupId}`);
-                // Get the memory key for the specified agent
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res.status(404).json({ error: "Memory key not found for the specified agent" });
+                    return res
+                        .status(404)
+                        .json({ error: "Memory key not found for the specified agent" });
                 }
                 console.log(`Memory key found: ${memoryKey}`);
-                // Use the Redis client to get the memory contents
                 const memoryContents = await req.redisClient.get(memoryKey);
                 if (!memoryContents) {
                     console.log(`Memory contents not found for key ${memoryKey}`);
                     return res.status(404).json({ error: "Memory contents not found" });
                 }
                 console.log(`Memory contents retrieved successfully`);
-                // Parse the memory contents (assuming it's stored as JSON)
                 const parsedMemoryContents = JSON.parse(memoryContents);
                 res.json(parsedMemoryContents);
             }
@@ -394,261 +359,17 @@ export class PolicySynthAgentsController {
         this.agentConnectorManager = new AgentConnectorManager();
         this.agentRegistryManager = new AgentRegistryManager();
         this.initializeRoutes();
-        this.initializeModels();
-        this.setupAiModels();
+        // Call our separated model setup methods.
+        NewAiModelSetup.initializeModels();
+        // Using a hardcoded userId (1) for seeding test AI models.
+        NewAiModelSetup.setupAiModels(1);
     }
-    async setupAiModels() {
-        setTimeout(async () => {
-            console.log("Seeding test AI models");
-            await this.seedTestAiModels(1);
-        }, 100);
-    }
-    async seedTestAiModels(userId) {
-        const testModel = await PsAiModel.findOne({
-            where: {
-                name: "Anthropic Sonnet 3.5",
-            },
-        });
-        if (!testModel) {
-            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 anthropicSonnet = await PsAiModel.create({
-                name: "Anthropic Sonnet 3.5",
-                organization_id: 1,
-                user_id: userId,
-                configuration: anthropicSonnetConfig,
-            });
-            console.log("Created test AI model:", anthropicSonnet);
-            const openAiGpt4oConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Medium,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 5,
-                    costOutTokensPerMillion: 15,
-                    currency: "USD",
-                },
-                maxTokensOut: 4096,
-                defaultTemperature: 0.7,
-                model: "gpt-4o",
-                active: true,
-            };
-            const openAiGpt4oMiniConfig = {
-                type: PsAiModelType.Text,
-                modelSize: PsAiModelSize.Small,
-                provider: "openai",
-                prices: {
-                    costInTokensPerMillion: 0.15,
-                    costOutTokensPerMillion: 0.6,
-                    currency: "USD",
-                },
-                maxTokensOut: 16000,
-                defaultTemperature: 0.0,
-                model: "gpt-4o-mini",
-                active: true,
-            };
-            const openAiGpt4 = await PsAiModel.create({
-                name: "GPT-4o",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt4oConfig,
-            });
-            console.log("Created test AI model:", openAiGpt4);
-            const openAiGpt4Mini = await PsAiModel.create({
-                name: "GPT-4o Mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAiGpt4oMiniConfig,
-            });
-            console.log("Created test AI model:", openAiGpt4Mini);
-            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: ["large", "medium", "small"],
-                supportedConnectors: [],
-            };
-            await PsAgentClass.create({
-                class_base_id: "c375c1fb-58ca-4372-a567-0e02b2c3d479",
-                name: "Operations",
-                version: 1,
-                available: true,
-                configuration: topLevelAgentClassConfig,
-                user_id: userId,
-            });
-        }
-        else {
-            console.log("Test AI models already exist");
-        }
-        const testOMiniModel = await PsAiModel.findOne({
-            where: {
-                name: "o1 Mini",
-            },
-        });
-        if (!testOMiniModel) {
-            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,
-            };
-            const openAio1Mini = await PsAiModel.create({
-                name: "o1 Mini",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio1MiniConfig,
-            });
-        }
-        else {
-            console.log("Test O models already exist");
-        }
-        const testOPreviewModel = await PsAiModel.findOne({
-            where: {
-                name: "o1 Preview",
-            },
-        });
-        if (!testOPreviewModel) {
-            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,
-            };
-            const openAio1Preview = await PsAiModel.create({
-                name: "o1 Preview",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio1PreviewConfig,
-            });
-        }
-        else {
-            console.log("Test O preview models already exist");
-        }
-        const testO1712Model = await PsAiModel.findOne({
-            where: {
-                name: "o1 24",
-            },
-        });
-        if (!testO1712Model) {
-            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-2024-12-17",
-                active: true,
-            };
-            const openAio11712 = await PsAiModel.create({
-                name: "o1 24",
-                organization_id: 1,
-                user_id: userId,
-                configuration: openAio11712Config,
-            });
-        }
-        else {
-            console.log("Test o1 1712 models already exist");
-        }
-        const geminiProModel = await PsAiModel.findOne({
-            where: {
-                name: "Gemini 1.5 Pro 2",
-            },
-        });
-        if (!geminiProModel) {
-            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,
-            };
-            const geminiPro = await PsAiModel.create({
-                name: "Gemini 1.5 Pro 2",
-                organization_id: 1,
-                user_id: userId,
-                configuration: geminiProConfig,
-            });
-        }
-        else {
-            console.log("Gemini 1.5 Pro 2 models already exist");
-        }
-        const geminiPro15FlashModel = await PsAiModel.findOne({
-            where: {
-                name: "Gemini 1.5 Flash 2",
-            },
-        });
-        if (!geminiPro15FlashModel) {
-            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,
-            };
-            const geminiPro15Flash = await PsAiModel.create({
-                name: "Gemini 1.5 Flash 2",
-                organization_id: 1,
-                user_id: userId,
-                configuration: geminiPro15FlashConfig,
-            });
-        }
+    /**
+     * A proxy for setting up API keys for a group.
+     * @param group The group instance to configure
+     */
+    static async setupApiKeysForGroup(group) {
+        return NewAiModelSetup.setupApiKeysForGroup(group);
     }
     initializeRoutes() {
         this.router.get("/:groupId", auth.can("view group"), this.getAgent);
@@ -672,77 +393,3 @@ export class PolicySynthAgentsController {
         this.router.post("/:groupId/:agentId/:type(input|output)Connectors/existing", auth.can("edit group"), this.addExistingConnector);
     }
 }
-_a = PolicySynthAgentsController;
-PolicySynthAgentsController.setupApiKeysForGroup = async (group) => {
-    const findLatestActiveModel = async (name) => {
-        return await PsAiModel.findOne({
-            where: {
-                name,
-                configuration: {
-                    active: true
-                }
-            },
-            order: [['created_at', 'DESC']],
-        });
-    };
-    const anthropicSonnet = await findLatestActiveModel("Anthropic Sonnet 3.5");
-    const openAiGpt4 = await findLatestActiveModel("GPT-4o");
-    const openAiGpt4Mini = await findLatestActiveModel("GPT-4o Mini");
-    const geminiPro = await findLatestActiveModel("Gemini 1.5 Pro 2");
-    const geminiPro15Flash = await findLatestActiveModel("Gemini 1.5 Flash 2");
-    const openAio1Preview = await findLatestActiveModel("o1 Preview");
-    const openAio1Mini = await findLatestActiveModel("o1 Mini");
-    const openAio11712 = await findLatestActiveModel("o1 24");
-    const groupAccessConfig = [];
-    if (anthropicSonnet && process.env.ANTHROPIC_CLAUDE_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: anthropicSonnet.id,
-            apiKey: process.env.ANTHROPIC_CLAUDE_API_KEY,
-        });
-    }
-    if (openAiGpt4 && process.env.OPENAI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: openAiGpt4.id,
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    if (openAiGpt4Mini && process.env.OPENAI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: openAiGpt4Mini.id,
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    if (openAio1Preview && process.env.OPENAI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: openAio1Preview.id,
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    if (openAio1Mini && process.env.OPENAI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: openAio1Mini.id,
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    if (geminiPro && process.env.GEMINI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: geminiPro.id,
-            apiKey: process.env.GEMINI_API_KEY,
-        });
-    }
-    if (geminiPro15Flash && process.env.GEMINI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: geminiPro15Flash.id,
-            apiKey: process.env.GEMINI_API_KEY,
-        });
-    }
-    if (openAio11712 && process.env.OPENAI_API_KEY) {
-        groupAccessConfig.push({
-            aiModelId: openAio11712.id,
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    group.set("private_access_configuration", groupAccessConfig);
-    group.changed("private_access_configuration", true);
-    await group.save();
-};