@yrpri/api 9.0.101 → 9.0.103

package/dist/agents/controllers/assistantsController.js

@@ -0,0 +1,511 @@
+import express from "express";
+import { marked } from "marked";
+import HTMLtoDOCX from "html-to-docx";
+import auth from "../../authorization.cjs";
+import { YpAgentAssistant } from "../assistants/agentAssistant.js";
+import { YpAgentProductBundle } from "../models/agentProductBundle.js";
+import { YpAgentProductRun } from "../models/agentProductRun.js";
+import { YpAgentProduct } from "../models/agentProduct.js";
+import { YpAgentProductBoosterPurchase } from "../models/agentProductBoosterPurchase.js";
+import { YpSubscription } from "../models/subscription.js";
+import { YpSubscriptionPlan } from "../models/subscriptionPlan.js";
+import { YpSubscriptionUser } from "../models/subscriptionUser.js";
+import { YpDiscount } from "../models/discount.js";
+import { sequelize } from "@policysynth/agents/dbModels/index.js";
+import { NotificationAgentQueueManager } from "../managers/notificationAgentQueueManager.js";
+import { AgentQueueManager } from "@policysynth/agents/operations/agentQueueManager.js";
+import { WorkflowConversationManager } from "../managers/workflowConversationManager.js";
+const models = {
+    YpAgentProduct,
+    YpAgentProductBundle,
+    YpAgentProductBoosterPurchase,
+    YpAgentProductRun,
+    YpSubscription,
+    YpSubscriptionPlan,
+    YpSubscriptionUser,
+    YpDiscount,
+};
+export class AssistantController {
+    constructor(wsClients) {
+        this.path = "/api/assistants";
+        this.router = express.Router();
+        this.chatAssistantInstances = new Map();
+        this.voiceAssistantInstances = new Map();
+        this.initializeModels = async () => {
+            try {
+                console.log(`All Models Loaded Init`);
+                // Call associate method to set up associations
+                for (const modelName of Object.keys(models)) {
+                    if (models[modelName].associate) {
+                        await models[modelName].associate(sequelize.models);
+                        //await models[modelName].associate(models);
+                    }
+                }
+                console.log("All agentmodels initialized successfully.");
+            }
+            catch (error) {
+                console.error("Error initializing models:", error);
+                process.exit(1);
+            }
+        };
+        this.getDocxReport = async (req, res) => {
+            try {
+                const { agentId } = req.params;
+                let lastStatusMessage = await this.getLastStatusMessageFromDB(parseInt(agentId));
+                if (!lastStatusMessage) {
+                    return res.status(404).send("No status message found.");
+                }
+                const regex = /<markdownReport>([\s\S]*?)<\/markdownReport>/i;
+                const match = lastStatusMessage.match(regex);
+                console.debug(`match: ${JSON.stringify(match, null, 2)}`);
+                if (!match || match.length < 2) {
+                    console.error("No <markdownReport>...</markdownReport> content found.");
+                    return res
+                        .status(400)
+                        .send("No <markdownReport>...</markdownReport> content found.");
+                }
+                const markdownContent = match[1];
+                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);
+            }
+            catch (error) {
+                console.error("Error converting Markdown to DOCX:", error);
+                return res.status(500).send("Server error");
+            }
+        };
+        this.advanceOrStopCurrentWorkflowStep = async (req, res) => {
+            const { groupId, agentId, runId } = req.params;
+            const { status, wsClientId } = req.body;
+            try {
+                const notificationManager = new NotificationAgentQueueManager(this.wsClients);
+                await notificationManager.advanceWorkflowStepOrCompleteAgentRun(parseInt(runId), status, wsClientId);
+                res.sendStatus(200);
+            }
+            catch (error) {
+                console.error("Error advancing or stopping workflow:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.startNextWorkflowStep = async (req, res) => {
+            const { groupId, agentId } = req.params;
+            try {
+                //await this.agentQueueManager.startNextWorkflowStep(parseInt(agentId), parseInt(groupId));
+                res.sendStatus(200);
+            }
+            catch (error) {
+                console.error("Error starting next workflow step:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.stopCurrentWorkflowStep = async (req, res) => {
+            const { groupId, agentId } = req.params;
+            try {
+                //await this.agentQueueManager.stopCurrentWorkflowStep(parseInt(agentId), parseInt(groupId));
+                res.sendStatus(200);
+            }
+            catch (error) {
+                console.error("Error stopping current workflow step:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.getAgentConfigurationAnswers = async (req, res) => {
+            try {
+                if (!req.user) {
+                    return res.status(401).json({ error: "Unauthorized" });
+                }
+                const subscriptionId = parseInt(req.params.subscriptionId);
+                // Make sure the user can only fetch their own subscription
+                const subscription = await YpSubscription.findOne({
+                    where: {
+                        id: subscriptionId,
+                        user_id: req.user.id,
+                    },
+                });
+                if (!subscription) {
+                    return res.status(404).json({ error: "Subscription not found" });
+                }
+                // Extract the requiredQuestionsAnswered from subscription.configuration
+                const answers = subscription.configuration?.requiredQuestionsAnswered || [];
+                return 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 });
+            }
+        };
+        this.getUpdatedWorkflow = async (req, res) => {
+            const { runId } = req.params;
+            const userId = req.user?.id;
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+            try {
+                const agentRun = await YpAgentProductRun.findOne({
+                    where: {
+                        id: runId,
+                    },
+                    attributes: ["workflow", "status"],
+                    include: [
+                        {
+                            model: YpSubscription,
+                            as: "Subscription",
+                            attributes: ["id"],
+                            where: {
+                                user_id: userId,
+                            },
+                            required: true,
+                        },
+                    ],
+                });
+                res.send({ workflow: agentRun?.workflow, status: agentRun?.status });
+            }
+            catch (error) {
+                console.error("Error getting updated workflow:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.startWorkflowAgent = async (req, res) => {
+            const { groupId, agentId, wsClientId } = req.params;
+            try {
+                const notificationManager = new NotificationAgentQueueManager(this.wsClients);
+                await notificationManager.startAgentProcessingWithWsClient(parseInt(agentId), parseInt(groupId), wsClientId);
+                res.sendStatus(200);
+            }
+            catch (error) {
+                console.error("Error starting agent:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.submitAgentConfiguration = async (req, res) => {
+            console.log(`submitAgentConfiguration: ${JSON.stringify(req.body, null, 2)}`);
+            const { requiredQuestionsAnswers } = req.body;
+            const subscriptionId = parseInt(req.params.subscriptionId);
+            try {
+                const memoryId = this.getMemoryRedisKey(req);
+                // Get subscription
+                const subscription = await YpSubscription.findOne({
+                    where: {
+                        id: subscriptionId,
+                        user_id: req.user?.id, //TODO: Move to move this access check to the group level
+                    },
+                });
+                if (!subscription) {
+                    res.sendStatus(404);
+                    return;
+                }
+                subscription.configuration.requiredQuestionsAnswered =
+                    requiredQuestionsAnswers;
+                subscription.changed("configuration", true);
+                await subscription.save();
+            }
+            catch (error) {
+                console.error("Error saving subscription:", error);
+                res.sendStatus(500);
+                return;
+            }
+            res.sendStatus(200);
+        };
+        this.updateAssistantMemoryLoginStatus = async (req, res) => {
+            if (!req.user) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+            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);
+            }
+            catch (error) {
+                console.error("Error updating login status:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.defaultStartAgentMode = "agent_selection_mode";
+        this.clearChatLog = async (req, res) => {
+            try {
+                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 user found to clear runs for");
+                }
+                res.sendStatus(200);
+            }
+            catch (error) {
+                console.error("Error clearing chat log:", error);
+                res.sendStatus(500);
+            }
+        };
+        this.getMemory = async (req, res) => {
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
+                return;
+            console.log(`Getting memory at key: ${memory.redisKey}`);
+            return 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" });
+            }
+            try {
+                const workflows = await this.workflowConversationManager.getRunningWorkflowConversationsForUser(req.user.id);
+                res.status(200).json({
+                    success: true,
+                    data: { workflows },
+                    message: "Running workflows retrieved successfully",
+                });
+            }
+            catch (error) {
+                console.error("Error retrieving running workflows:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.getAllWorkflowConversations = async (req, res) => {
+            if (!req.user || !req.user.id) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+            try {
+                const workflows = await this.workflowConversationManager.getWorkflowConversationsForUser(req.user.id);
+                res.status(200).json({
+                    success: true,
+                    data: { workflows },
+                    message: "All workflows retrieved successfully",
+                });
+            }
+            catch (error) {
+                console.error("Error retrieving all workflows:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.connectToWorkflowConversation = async (req, res) => {
+            if (!req.user || !req.user.id) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+            try {
+                const { workflowConversationId, connectionData } = req.body;
+                const updatedWorkflowConversation = await this.workflowConversationManager.connectToWorkflowConversation(workflowConversationId, connectionData || {});
+                res.status(200).json({
+                    success: true,
+                    data: updatedWorkflowConversation,
+                    message: `Connected to workflow conversation ${workflowConversationId} successfully`,
+                });
+            }
+            catch (error) {
+                console.error("Error connecting to workflow conversation:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.wsClients = wsClients;
+        this.agentQueueManager = new AgentQueueManager();
+        this.workflowConversationManager = new WorkflowConversationManager();
+        this.initializeRoutes();
+        this.initializeModels();
+    }
+    initializeRoutes() {
+        this.router.put("/:domainId/chat", auth.can("view domain"), this.sendChatMessage.bind(this));
+        this.router.post("/:domainId/voice", auth.can("view domain"), this.startVoiceSession.bind(this));
+        this.router.get("/:domainId/memory", auth.can("view domain"), this.getMemory.bind(this));
+        this.router.delete("/:domainId/chatlog", auth.can("view domain"), this.clearChatLog.bind(this));
+        //TODO: Add auth for below
+        this.router.put("/:domainId/updateAssistantMemoryLoginStatus", this.updateAssistantMemoryLoginStatus.bind(this));
+        this.router.put("/:domainId/:subscriptionId/submitAgentConfiguration", this.submitAgentConfiguration.bind(this));
+        this.router.get("/:domainId/:subscriptionId/getConfigurationAnswers", this.getAgentConfigurationAnswers.bind(this));
+        this.router.put("/:groupId/:agentId/startWorkflowAgent", this.startWorkflowAgent.bind(this));
+        this.router.get("/:groupId/:runId/updatedWorkflow", this.getUpdatedWorkflow.bind(this));
+        this.router.post("/:groupId/:agentId/startNextWorkflowStep", this.startNextWorkflowStep.bind(this));
+        this.router.post("/:groupId/:agentId/stopCurrentWorkflowStep", this.stopCurrentWorkflowStep.bind(this));
+        this.router.put("/:groupId/:agentId/:runId/advanceOrStopWorkflow", this.advanceOrStopCurrentWorkflowStep.bind(this));
+        this.router.get("/:groupId/:agentId/getDocxReport", auth.can("view domain"), this.getDocxReport.bind(this));
+        this.router.get("/:domainId/workflowConversations/running", auth.can("view domain"), this.getRunningWorkflowConversations.bind(this));
+        this.router.get("/:domainId/workflowConversations/all", auth.can("view domain"), this.getAllWorkflowConversations.bind(this));
+        this.router.put("/:domainId/workflowConversations/connect", auth.can("view domain"), this.connectToWorkflowConversation.bind(this));
+    }
+    async getLastStatusMessageFromDB(agentId) {
+        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 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) {
+                oldVoiceAssistant.destroy();
+                this.voiceAssistantInstances.delete("voiceAssistant");
+            }
+            let oldChatAssistant = this.chatAssistantInstances.get("mainAssistant");
+            if (oldChatAssistant) {
+                oldChatAssistant.destroy();
+                this.chatAssistantInstances.delete("mainAssistant");
+            }
+            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({
+                message: "Voice session initialized",
+                wsClientId,
+            });
+        }
+        catch (error) {
+            console.error("Error starting voice session:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+    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 oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
+            if (oldVoiceAssistant) {
+                oldVoiceAssistant.destroy();
+                this.voiceAssistantInstances.delete("voiceAssistant");
+            }
+            const oldAssistant = this.chatAssistantInstances.get("mainAssistant");
+            if (oldAssistant) {
+                oldAssistant.destroy();
+                this.chatAssistantInstances.delete("mainAssistant");
+            }
+            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({
+                message: "Chat session initialized",
+                wsClientId,
+            });
+        }
+        catch (error) {
+            console.error("Error starting chat session:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+}