@yrpri/api 9.0.101 → 9.0.103

package/agents/controllers/assistantsController.js

@@ -53,28 +53,33 @@ export class AssistantController {
                 const { agentId } = req.params;
                 let lastStatusMessage = await this.getLastStatusMessageFromDB(parseInt(agentId));
                 if (!lastStatusMessage) {
-                    return res.status(404).send("No status message found.");
+                    res.status(404).send("No status message found.");
                 }
                 const regex = /<markdownReport>([\s\S]*?)<\/markdownReport>/i;
-                const match = lastStatusMessage.match(regex);
+                const match = lastStatusMessage ? lastStatusMessage.match(regex) : null;
                 console.debug(`match: ${JSON.stringify(match, null, 2)}`);
                 if (!match || match.length < 2) {
                     console.error("No <markdownReport>...</markdownReport> content found.");
-                    return res
+                    res
                         .status(400)
                         .send("No <markdownReport>...</markdownReport> content found.");
                 }
-                const markdownContent = match[1];
+                const markdownContent = match ? match[1] : null;
+                if (!markdownContent) {
+                    console.error("No markdown content found.");
+                    res.status(400).send("No markdown content found.");
+                    return;
+                }
                 const htmlContent = await marked(markdownContent);
                 const docxBuffer = (await HTMLtoDOCX(htmlContent));
                 console.debug(`docxBuffer: ${docxBuffer.length}`);
                 res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
                 res.setHeader("Content-disposition", 'attachment; filename="converted.docx"');
-                return res.send(docxBuffer);
+                res.send(docxBuffer);
             }
             catch (error) {
                 console.error("Error converting Markdown to DOCX:", error);
-                return res.status(500).send("Server error");
+                res.status(500).send("Server error");
             }
         };
         this.advanceOrStopCurrentWorkflowStep = async (req, res) => {
@@ -115,7 +120,8 @@ export class AssistantController {
         this.getAgentConfigurationAnswers = async (req, res) => {
             try {
                 if (!req.user) {
-                    return res.status(401).json({ error: "Unauthorized" });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
                 }
                 const subscriptionId = parseInt(req.params.subscriptionId);
                 // Make sure the user can only fetch their own subscription
@@ -126,25 +132,26 @@ export class AssistantController {
                     },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
                 }
                 // Extract the requiredQuestionsAnswered from subscription.configuration
-                const answers = subscription.configuration?.requiredQuestionsAnswered || [];
-                return res.status(200).json({
+                const answers = subscription?.configuration?.requiredQuestionsAnswered || [];
+                res.status(200).json({
                     success: true,
                     data: answers,
                 });
             }
             catch (error) {
                 console.error("Error retrieving subscription agent configuration:", error);
-                return res.status(500).json({ error: error.message });
+                res.status(500).json({ error: error.message });
             }
         };
         this.getUpdatedWorkflow = async (req, res) => {
             const { runId } = req.params;
             const userId = req.user?.id;
             if (!userId) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const agentRun = await YpAgentProductRun.findOne({
@@ -188,7 +195,7 @@ export class AssistantController {
             const { requiredQuestionsAnswers } = req.body;
             const subscriptionId = parseInt(req.params.subscriptionId);
             try {
-                const memoryId = this.getMemoryUserId(req);
+                const memoryId = this.getMemoryRedisKey(req);
                 // Get subscription
                 const subscription = await YpSubscription.findOne({
                     where: {
@@ -208,85 +215,62 @@ export class AssistantController {
             catch (error) {
                 console.error("Error saving subscription:", error);
                 res.sendStatus(500);
-                return;
             }
             res.sendStatus(200);
         };
         this.updateAssistantMemoryLoginStatus = async (req, res) => {
-            if (req.user && req.params.domainId) {
-                try {
-                    let memoryId = this.getMemoryUserId(req);
-                    let redisKey = YpAgentAssistant.getRedisKey(memoryId);
-                    console.log(`Starting to update login status for memoryId: ${memoryId} with user: ${req.user?.name}`);
-                    let memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                    if (memory) {
-                        memory.currentUser = req.user;
-                        await req.redisClient.set(redisKey, JSON.stringify(memory));
-                        //TODO: Check if needed, wait for 300ms to make sure redis is saved
-                        await new Promise((resolve) => setTimeout(resolve, 300));
-                        console.log(`Updated login status for memoryId: ${memoryId} with user: ${req.user?.name}`);
-                    }
-                    else {
-                        console.error(`No memory found to update login status for id ${memoryId}`);
-                    }
-                    res.sendStatus(200);
-                }
-                catch (error) {
-                    console.error("Error updating login status:", error);
-                    res.sendStatus(500);
-                }
+            if (!req.user) {
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
-            else {
-                res.sendStatus(401);
+            try {
+                const memory = await this.loadMemoryWithOwnership(req, res);
+                if (!memory)
+                    return; // already 401/403 if not allowed
+                // Now memory is either newly created or already owned by this user (or still guest if you didn't upgrade)
+                memory.currentUser = req.user;
+                await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
+                res.sendStatus(200);
             }
-        };
-        this.defaultStartAgentMode = "agent_selection_mode";
-        this.getMemoryUserId = (req) => {
-            const userIdentifier = req.body.clientMemoryUuid || req.query.clientMemoryUuid;
-            if (!userIdentifier) {
-                throw new Error("No user identifier found");
+            catch (error) {
+                console.error("Error updating login status:", error);
+                res.sendStatus(500);
             }
-            return `${req.params.domainId}-${userIdentifier}`;
         };
+        this.defaultStartAgentMode = "agent_selection_mode";
         this.clearChatLog = async (req, res) => {
             try {
-                const memoryId = this.getMemoryUserId(req);
-                console.log(`Clearing chat log for memoryId: ${memoryId}`);
-                const redisKey = YpAgentAssistant.getRedisKey(memoryId);
-                const memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                if (memory) {
-                    if (!memory.allChatLogs) {
-                        memory.allChatLogs = [];
-                    }
-                    if (memory.chatLog) {
-                        memory.allChatLogs = [...memory.allChatLogs, ...memory.chatLog];
-                    }
-                    memory.chatLog = [];
-                    memory.currentMode = this.defaultStartAgentMode;
-                    memory.haveShownConfigurationWidget = false;
-                    memory.haveShownLoginWidget = false;
-                    memory.currentAgentStatus = undefined;
-                    if (!req.user) {
-                        memory.currentUser = undefined;
-                    }
-                    await req.redisClient.set(redisKey, JSON.stringify(memory));
-                    if (req.user) {
-                        //TODO: REMOVE THIS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
-                        await YpSubscription.destroy({
-                            where: {
-                                user_id: req.user?.id,
-                            },
-                        });
-                    }
-                    else {
-                        console.warn("No user found to clear runs for");
-                    }
-                    res.sendStatus(200);
+                const memory = await this.loadMemoryWithOwnership(req, res);
+                if (!memory)
+                    return; // loadMemoryWithOwnership has already sent 401/403 if needed
+                // Now we know this request is allowed to see/modify the memory
+                if (!memory.allChatLogs) {
+                    memory.allChatLogs = [];
+                }
+                if (memory.chatLog) {
+                    memory.allChatLogs = [...memory.allChatLogs, ...memory.chatLog];
+                }
+                memory.chatLog = [];
+                memory.currentMode = this.defaultStartAgentMode;
+                memory.haveShownConfigurationWidget = false;
+                memory.haveShownLoginWidget = false;
+                memory.currentAgentStatus = undefined;
+                if (!req.user && memory.ownerUserId === null) {
+                    memory.currentUser = undefined;
+                }
+                await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
+                if (req.user) {
+                    //TODO: REMOVE THIS when we have multi workflows
+                    await YpSubscription.destroy({
+                        where: {
+                            user_id: req.user?.id,
+                        },
+                    });
                 }
                 else {
-                    console.warn(`No memory found to clear for id ${memoryId}`);
-                    res.sendStatus(200);
+                    console.warn("No user found to clear runs for");
                 }
+                res.sendStatus(200);
             }
             catch (error) {
                 console.error("Error clearing chat log:", error);
@@ -294,52 +278,17 @@ export class AssistantController {
             }
         };
         this.getMemory = async (req, res) => {
-            let memory;
-            let memoryId;
-            try {
-                memoryId = this.getMemoryUserId(req);
-                console.log(`Getting memory for memoryId: ${memoryId}`);
-                if (memoryId) {
-                    memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                    if (!memory) {
-                        console.log(`memory not found for id ${memoryId}`);
-                        memory = {
-                            redisKey: YpAgentAssistant.getRedisKey(memoryId),
-                            chatLog: [],
-                            currentMode: this.defaultStartAgentMode,
-                            modeHistory: [],
-                            modeData: undefined,
-                        };
-                        await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
-                    }
-                    else {
-                        if (req.user && !memory.currentUser) {
-                            memory.currentUser = req.user;
-                        }
-                        else if (!req.user && memory.currentUser) {
-                            memory.currentUser = undefined;
-                        }
-                        await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
-                    }
-                }
-            }
-            catch (error) {
-                console.log(error);
-                res.sendStatus(500);
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
                 return;
-            }
-            if (memory) {
-                res.send(memory);
-            }
-            else {
-                console.error(`No memory found for memoryId: ${memoryId}`);
-                res.send({});
-            }
+            console.log(`Getting memory at key: ${memory.redisKey}`);
+            res.json(memory);
         };
         // New API endpoints for workflow management
         this.getRunningWorkflowConversations = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const workflows = await this.workflowConversationManager.getRunningWorkflowConversationsForUser(req.user.id);
@@ -356,7 +305,8 @@ export class AssistantController {
         };
         this.getAllWorkflowConversations = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const workflows = await this.workflowConversationManager.getWorkflowConversationsForUser(req.user.id);
@@ -373,7 +323,8 @@ export class AssistantController {
         };
         this.connectToWorkflowConversation = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const { workflowConversationId, connectionData } = req.body;
@@ -418,10 +369,102 @@ export class AssistantController {
         const status = await this.agentQueueManager.getAgentStatus(agentId);
         return status ? status.messages[status.messages.length - 1] : null;
     }
+    getMemoryRedisKey(req) {
+        const userIdentifier = req.body.clientMemoryUuid || req.query.clientMemoryUuid;
+        return `assistant:${ /*req.params.domainId*/1}:${userIdentifier}`;
+    }
+    async loadMemoryWithOwnership(req, res) {
+        // Get the calling function name from the stack trace
+        const stackTrace = new Error().stack;
+        const callerLine = stackTrace?.split("\n")[2]; // First line is Error, second is current function, third is caller
+        const callerMatch = callerLine?.match(/at\s+(.*)\s+\(/);
+        const caller = callerMatch ? callerMatch[1] : "unknown";
+        console.debug(`loadMemoryWithOwnership called by: ${caller}`);
+        console.debug(`loadMemoryWithOwnership: ${JSON.stringify(req.body, null, 2)}`);
+        const redisKey = this.getMemoryRedisKey(req);
+        console.debug(`loadMemoryWithOwnership: redisKey: ${redisKey}`);
+        try {
+            const rawMemory = await req.redisClient.get(redisKey);
+            let memory = rawMemory
+                ? JSON.parse(rawMemory)
+                : null;
+            // If no memory, create new
+            if (!memory) {
+                console.debug(`loadMemoryWithOwnership: creating new memory`);
+                memory = {
+                    redisKey,
+                    chatLog: [],
+                    completeChatLog: [],
+                    currentMode: this.defaultStartAgentMode,
+                    modeHistory: [],
+                    modeData: undefined,
+                    ownerUserId: null,
+                };
+                if (req.user) {
+                    console.debug(`loadMemoryWithOwnership: setting ownerUserId to ${req.user.id}`);
+                    memory.ownerUserId = req.user.id;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: no user in request`);
+                }
+                await req.redisClient.set(redisKey, JSON.stringify(memory));
+                const rawAfterSet = await req.redisClient.get(redisKey);
+                console.log("loadMemoryWithOwnership: After set, raw in Redis is:", rawAfterSet);
+                console.debug(`loadMemoryWithOwnership: returning new memory`);
+                return memory;
+            }
+            else {
+                console.debug(`loadMemoryWithOwnership: memory already exists`);
+                console.debug(`loadMemoryWithOwnership: memory: ${JSON.stringify(memory, null, 2)}`);
+            }
+            // If memory is owned by someone
+            if (memory.ownerUserId !== null) {
+                console.debug(`loadMemoryWithOwnership: memory is owned by ${memory.ownerUserId}`);
+                if (!req.user) {
+                    console.debug(`loadMemoryWithOwnership: no user in request`);
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: user in request`);
+                }
+                if (memory.ownerUserId !== req.user.id) {
+                    console.debug(`loadMemoryWithOwnership: ownerUserId does not match ${memory.ownerUserId} !== ${req.user.id}`);
+                    res.status(403).json({ error: "Forbidden" });
+                    return;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: ownerUserId matches ${memory.ownerUserId} === ${req.user.id}`);
+                }
+                // Same user => fine
+                return memory;
+            }
+            else {
+                // memory is guest
+                if (req.user) {
+                    // optionally upgrade
+                    memory.ownerUserId = req.user.id;
+                    await req.redisClient.set(redisKey, JSON.stringify(memory));
+                    console.debug(`loadMemoryWithOwnership: returning memory with ownerUserId ${memory.ownerUserId}`);
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: returning memory with ownerUserId null`);
+                }
+                return memory;
+            }
+        }
+        catch (error) {
+            console.error("Error loading memory:", error);
+            res.status(500).json({ error: "Internal server error" });
+            return;
+        }
+    }
     async startVoiceSession(req, res) {
         try {
             const { wsClientId, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
+                return;
             console.log(`Starting chat session for client: ${wsClientId}`);
             let oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
             if (oldVoiceAssistant) {
@@ -433,7 +476,7 @@ export class AssistantController {
                 oldChatAssistant.destroy();
                 this.chatAssistantInstances.delete("mainAssistant");
             }
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, parseInt(req.params.domainId), memoryId);
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, memory.redisKey, parseInt(req.params.domainId));
             this.voiceAssistantInstances.set("voiceAssistant", assistant);
             await assistant.initialize();
             res.status(200).json({
@@ -448,9 +491,10 @@ export class AssistantController {
     }
     async sendChatMessage(req, res) {
         try {
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
+                return; // ends early if 401/403
             const { wsClientId, chatLog, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
-            console.log(`Starting chat session for client: ${wsClientId} with currentMode: ${currentMode}`);
             const oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
             if (oldVoiceAssistant) {
                 oldVoiceAssistant.destroy();
@@ -461,7 +505,7 @@ export class AssistantController {
                 oldAssistant.destroy();
                 this.chatAssistantInstances.delete("mainAssistant");
             }
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, parseInt(req.params.domainId), memoryId);
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, memory.redisKey, parseInt(req.params.domainId));
             this.chatAssistantInstances.set("mainAssistant", assistant);
             assistant.conversation(chatLog);
             res.status(200).json({

package/agents/controllers/policySynthAgents.js

@@ -22,23 +22,24 @@ export class PolicySynthAgentsController {
                 console.log(`Attempting to replace memory for agent ${agentId} in group ${groupId}`);
                 if (!memory || Object.keys(memory).length === 0) {
                     console.log(`Received empty memory for agent ${agentId}`);
-                    return res.status(400).json({ error: "Cannot save empty memory" });
+                    res.status(400).json({ error: "Cannot save empty memory" });
+                    return;
                 }
                 try {
                     JSON.parse(JSON.stringify(memory));
                 }
                 catch (jsonError) {
                     console.log(`Received invalid JSON for agent ${agentId}`);
-                    return res
-                        .status(400)
-                        .json({ error: "Invalid JSON format for memory" });
+                    res.status(400).json({ error: "Invalid JSON format for memory" });
+                    return;
                 }
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res
+                    res
                         .status(404)
                         .json({ error: "Memory key not found for the specified agent" });
+                    return;
                 }
                 console.log(`Memory key found: ${memoryKey}`);
                 await req.redisClient.set(memoryKey, JSON.stringify(memory));
@@ -53,15 +54,29 @@ export class PolicySynthAgentsController {
                 else {
                     res.status(500).json({ error: "An unexpected error occurred" });
                 }
+                return;
             }
         };
         this.addExistingConnector = async (req, res) => {
-            const { groupId, agentId, type } = req.params;
+            const { groupId, agentId } = req.params;
             const { connectorId } = req.body;
+            let type;
+            if (req.path.includes("/inputConnectors/")) {
+                type = "input";
+            }
+            else if (req.path.includes("/outputConnectors/")) {
+                type = "output";
+            }
+            else {
+                // This case should ideally not be reached if routes are set up correctly
+                res.status(400).send("Could not determine connector type from path");
+                return;
+            }
             if (!groupId || !agentId || !connectorId) {
-                return res
+                res
                     .status(400)
                     .send("Group ID, agent ID and connector ID (input/output) are required");
+                return;
             }
             try {
                 await this.agentConnectorManager.addExistingConnector(parseInt(groupId), parseInt(agentId), parseInt(connectorId), type);
@@ -86,15 +101,17 @@ export class PolicySynthAgentsController {
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res
+                    res
                         .status(404)
                         .json({ error: "Memory key not found for the specified agent" });
+                    return;
                 }
                 console.log(`Memory key found: ${memoryKey}`);
                 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" });
+                    res.status(404).json({ error: "Memory contents not found" });
+                    return;
                 }
                 console.log(`Memory contents retrieved successfully`);
                 const parsedMemoryContents = JSON.parse(memoryContents);
@@ -108,6 +125,7 @@ export class PolicySynthAgentsController {
                 else {
                     res.status(500).json({ error: "An unexpected error occurred" });
                 }
+                return;
             }
         };
         this.getAgent = async (req, res) => {
@@ -118,6 +136,7 @@ export class PolicySynthAgentsController {
             catch (error) {
                 console.error("Error in getAgent:", error);
                 res.status(500).send("Internal Server Error");
+                return;
             }
         };
         this.getAgentAiModels = async (req, res) => {
@@ -163,13 +182,15 @@ export class PolicySynthAgentsController {
                     await this.agentConnectorManager.updateConnectorConfiguration(nodeId, updatedConfig);
                 }
                 else {
-                    return res.status(400).send("Invalid node type");
+                    res.status(400).send("Invalid node type");
+                    return;
                 }
                 res.json({ message: `${nodeType} configuration updated successfully` });
             }
             catch (error) {
                 console.error(`Error updating ${nodeType} configuration:`, error);
                 res.status(500).send("Internal Server Error");
+                return;
             }
         };
         this.createInputConnector = async (req, res) => {
@@ -388,8 +409,8 @@ export class PolicySynthAgentsController {
         this.router.get("/:groupId/:id/ai-models", auth.can("view group"), this.getAgentAiModels);
         this.router.delete("/:groupId/:agentId/ai-models/:modelId", auth.can("edit group"), this.removeAgentAiModel);
         this.router.post("/:groupId/:agentId/ai-models", auth.can("edit group"), this.addAgentAiModel);
-        this.router.get("/:groupId/:agentId/memory", auth.can("view group"), this.getAgentMemory);
         this.router.put("/:groupId/:agentId/memory", auth.can("edit group"), this.replaceAgentMemory);
-        this.router.post("/:groupId/:agentId/:type(input|output)Connectors/existing", auth.can("edit group"), this.addExistingConnector);
+        this.router.post("/:groupId/:agentId/inputConnectors/existing", auth.can("edit group"), this.addExistingConnector);
+        this.router.post("/:groupId/:agentId/outputConnectors/existing", auth.can("edit group"), this.addExistingConnector);
     }
 }

package/agents/managers/newAiModelSetup.js

@@ -336,6 +336,99 @@ export class NewAiModelSetup {
         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.
@@ -533,6 +626,9 @@ export class NewAiModelSetup {
             { 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) {