@yrpri/api 9.0.101 → 9.0.103

package/dist/agents/managers/notificationAgentQueueManager.js

@@ -0,0 +1,510 @@
+import { Queue, QueueEvents } from "bullmq";
+import { AgentQueueManager } from "@policysynth/agents/operations/agentQueueManager.js";
+import { PsAgent } from "@policysynth/agents/dbModels/agent.js";
+import { PsAgentClass } from "@policysynth/agents/dbModels/agentClass.js";
+import { YpAgentProductRun } from "../models/agentProductRun.js";
+import models from "../../models/index.cjs";
+import { YpSubscriptionPlan } from "../models/subscriptionPlan.js";
+import { YpAgentProduct } from "../models/agentProduct.js";
+import { YpSubscription } from "../models/subscription.js";
+import { YpAgentProductBundle } from "../models/agentProductBundle.js";
+import queue from "../../active-citizen/workers/queue.cjs";
+import { EmailTemplateRenderer } from "./emailTemplateRenderer.js";
+const dbModels = models;
+const Group = dbModels.Group;
+const User = dbModels.User;
+const Community = dbModels.Community;
+const Domain = dbModels.Domain;
+export class NotificationAgentQueueManager extends AgentQueueManager {
+    constructor(wsClients) {
+        super();
+        console.log("NotificationAgentQueueManager: Initializing");
+        this.initializeRedis();
+        this.queues = new Map();
+        this.wsClients = wsClients;
+    }
+    async sendNotification(agent, agentRun, action, wsClientId, status, result, agentRunId, updatedWorkflow) {
+        console.log("NotificationAgentQueueManager: Sending notification", agentRunId, updatedWorkflow);
+        const wsClient = this.wsClients.get(wsClientId);
+        if (wsClient) {
+            const currentWorkflowStep = updatedWorkflow?.steps[updatedWorkflow?.currentStepIndex];
+            wsClient.send(JSON.stringify({
+                type: "updated_workflow",
+                action,
+                status,
+                result,
+                agentRunId,
+                updatedWorkflow: {
+                    workflow: updatedWorkflow,
+                    status: status,
+                    currentWorkflowStep,
+                },
+            }));
+        }
+        else {
+            console.error(`NotificationAgentQueueManager: WebSocket client with ID ${wsClientId} not found`);
+        }
+        if (updatedWorkflow) {
+            await this.sendNotificationEmail(agent, agentRun, updatedWorkflow);
+        }
+        else {
+            console.error("NotificationAgentQueueManager: No updated workflow found");
+        }
+    }
+    async sendNotificationEmail(agent, agentRun, updatedWorkflow) {
+        // Send email notification
+        const subject = `${agentRun.Subscription?.Plan?.AgentProduct?.name} - ${updatedWorkflow?.steps[updatedWorkflow?.currentStepIndex]?.shortName} ready`;
+        const bundleId = agentRun.Subscription?.Plan?.AgentProduct?.AgentBundles?.[0]?.id || 1;
+        const currentWorkflowStep = updatedWorkflow?.steps[updatedWorkflow?.currentStepIndex];
+        const userId = agentRun.Subscription?.user_id;
+        const group = (await Group.findOne({
+            where: { id: agent.group_id },
+            include: [
+                { model: User, as: "GroupAdmins" },
+                {
+                    model: Community,
+                    attributes: ["id", "name"],
+                    include: [
+                        { model: Domain, attributes: ["id", "name", "domain_name"] },
+                    ],
+                },
+            ],
+        }));
+        const link = `https://app.${group.Community?.Domain?.domain_name}/agent_bundle/${bundleId}?needsLogin=true`;
+        if (group && group.GroupAdmins && group.GroupAdmins.length > 0) {
+            let admins = group.GroupAdmins.filter((admin) => admin.email);
+            const emailContent = EmailTemplateRenderer.renderEmail("", "", agentRun.Subscription?.Plan?.AgentProduct?.name || "", updatedWorkflow, link, "https://evoly.ai/is/amplifier/img/amplifier-logo.png", "https://evoly.ai/is/amplifier/img/evoly-bw-logo.png", "https://evoly.ai/", "© 2024 Evoly ehf, Vegmuli 8, 108, Reykjavik, Iceland");
+            const MAX_ADMIN_EMAILS = 25;
+            // Deduplicate admins using Set
+            admins = Array.from(new Set(admins.map((admin) => admin.email)))
+                .map((email) => admins.find((admin) => admin.email === email))
+                .filter((admin) => admin !== undefined);
+            for (let u = 0; u < Math.min(admins.length, MAX_ADMIN_EMAILS); u++) {
+                queue.add("send-one-email", {
+                    subject: subject,
+                    template: "general_user_notification",
+                    user: admins[u],
+                    domain: group.Community?.Domain,
+                    group: group,
+                    object: agent,
+                    header: "",
+                    content: emailContent,
+                    link: link,
+                    skipHeaderAndFooter: true,
+                }, { priority: "high" });
+            }
+        }
+        else {
+            console.error("No group admins with email found");
+            return;
+        }
+    }
+    async goBackOneWorkflowStepIfNeeded(agentRunId, status, wsClientId, currentWorkflowStepIndex = undefined) {
+        // Get the agent run record
+        const agentRun = await YpAgentProductRun.findByPk(agentRunId, {
+            attributes: ["id", "workflow", "status"],
+        });
+        if (!agentRun || !agentRun.workflow) {
+            console.error(`NotificationAgentQueueManager: Agent run ${agentRunId} or its workflow not found`);
+            return;
+        }
+        const workflowConfig = agentRun.workflow;
+        if (currentWorkflowStepIndex !== undefined &&
+            currentWorkflowStepIndex !== workflowConfig.currentStepIndex) {
+            console.error("NotificationAgentQueueManager: Current workflow step index is undefined or matches the current step index, not advancing to the next step");
+            return;
+        }
+        if (currentWorkflowStepIndex === 0) {
+            return;
+        }
+        else {
+            let lastStatus;
+            if (workflowConfig.steps[workflowConfig.currentStepIndex].type ===
+                "agentOps") {
+                lastStatus = "waiting_on_user";
+            }
+            else {
+                lastStatus = "running";
+            }
+            agentRun.status = lastStatus;
+            workflowConfig.currentStepIndex--;
+            agentRun.workflow = workflowConfig;
+            agentRun.changed("workflow", true);
+            agentRun.changed("status", true);
+            await agentRun.save();
+        }
+    }
+    async advanceWorkflowStepOrCompleteAgentRun(agentRunId, status, wsClientId, currentWorkflowStepIndex = undefined) {
+        try {
+            console.log("NotificationAgentQueueManager: Advancing workflow step or completing agent run", agentRunId, status);
+            // Get the agent run record
+            const agentRun = await YpAgentProductRun.findByPk(agentRunId, {
+                attributes: ["id", "workflow", "status"],
+                include: [
+                    {
+                        model: YpSubscription,
+                        as: "Subscription",
+                        attributes: ["id", "user_id"],
+                    },
+                ],
+            });
+            if (!agentRun || !agentRun.workflow) {
+                console.error(`NotificationAgentQueueManager: Agent run ${agentRunId} or its workflow not found`);
+                return;
+            }
+            const workflowConfig = agentRun.workflow;
+            if (status === "failed") {
+                // Mark the workflow as failed
+                await agentRun.update({ status: "failed", completedAt: new Date() });
+                return;
+            }
+            if (currentWorkflowStepIndex !== undefined &&
+                currentWorkflowStepIndex !== workflowConfig.currentStepIndex) {
+                console.error("NotificationAgentQueueManager: Current workflow step index is undefined or matches the current step index, not advancing to the next step");
+                return;
+            }
+            // Check if there are more steps
+            if (workflowConfig.currentStepIndex < workflowConfig.steps.length - 1) {
+                workflowConfig.currentStepIndex++;
+                let nextStatus;
+                if (workflowConfig.steps[workflowConfig.currentStepIndex].type ===
+                    "agentOps") {
+                    nextStatus = "running";
+                }
+                else {
+                    nextStatus = "waiting_on_user";
+                }
+                agentRun.status = nextStatus;
+                agentRun.workflow = workflowConfig;
+                agentRun.changed("status", true);
+                agentRun.changed("workflow", true);
+                await agentRun.save();
+                //TODO: UPDATE AGENT MEMORY, Maybe
+                console.log("NotificationAgentQueueManager: Updated workflow for agent run", agentRunId, status, workflowConfig);
+            }
+            else {
+                // This was the last step, mark the workflow as completed
+                agentRun.status = "completed";
+                agentRun.changed("status", true);
+                await agentRun.save();
+                await agentRun.update({ status: "completed", completedAt: new Date() });
+                console.log("NotificationAgentQueueManager: Updated workflow for agent run", agentRunId, "to completed");
+            }
+            return workflowConfig;
+        }
+        catch (error) {
+            console.error(`NotificationAgentQueueManager: Error in advanceWorkflowStepOrCompleteAgentRun:`, error);
+        }
+    }
+    static async getAgentRun(agentRunId) {
+        return await YpAgentProductRun.findOne({
+            where: { id: agentRunId },
+            attributes: ["id", "status", "workflow"],
+            include: [
+                {
+                    model: YpSubscription,
+                    as: "Subscription",
+                    attributes: ["id", "user_id"],
+                    include: [
+                        {
+                            model: YpSubscriptionPlan,
+                            attributes: ["id", "name"],
+                            as: "Plan",
+                            include: [
+                                {
+                                    model: YpAgentProduct,
+                                    attributes: ["id", "name", "description"],
+                                    as: "AgentProduct",
+                                    include: [
+                                        {
+                                            model: YpAgentProductBundle,
+                                            attributes: ["id", "name"],
+                                            as: "AgentBundles",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    getQueue(queueName) {
+        console.log(`NotificationAgentQueueManager: Getting queue for ${queueName}`);
+        if (!this.queues.has(queueName)) {
+            console.log(`NotificationAgentQueueManager: Creating new queue for ${queueName}`);
+            const newQueue = new Queue(queueName, {
+                connection: this.redisClient,
+            });
+            newQueue.on("error", (error) => {
+                console.log(`NotificationAgentQueueManager: Error in queue ${queueName}:`, error);
+            });
+            newQueue.on("waiting", (jobId) => {
+                console.log(`Job ${jobId} is waiting in queue ${queueName}`);
+            });
+            // Create QueueEvents instance for global events
+            const queueEvents = new QueueEvents(queueName, {
+                connection: this.redisClient,
+            });
+            // Add event listeners for debugging
+            queueEvents.on("waiting", ({ jobId }) => {
+                console.log(`Job ${jobId} is waiting in queue ${queueName}`);
+            });
+            queueEvents.on("active", ({ jobId, prev }) => {
+                console.log(`Job ${jobId} is active in queue ${queueName} (prev state: ${prev})`);
+            });
+            queueEvents.on("completed", async ({ jobId, returnvalue }) => {
+                console.log(`Job ${jobId} completed in queue ${queueName}. Result:`, returnvalue);
+                try {
+                    console.log("NotificationAgentQueueManager: Job completed in queue", queueName, jobId);
+                    // Retrieve the job instance
+                    const job = await newQueue.getJob(jobId);
+                    if (job) {
+                        const { agentId, type, wsClientId, agentRunId, currentWorkflowStepIndex, } = job.data;
+                        console.log("NotificationAgentQueueManager: Job data", job.data);
+                        console.log("NotificationAgentQueueManager: currentWorkflowStepIndex", currentWorkflowStepIndex);
+                        // Load the agent database record
+                        const agent = await PsAgent.findByPk(agentId, {
+                            include: [{ model: PsAgentClass, as: "Class" }],
+                        });
+                        const agentRun = await NotificationAgentQueueManager.getAgentRun(agentRunId);
+                        if (!agentRun) {
+                            console.error(`NotificationAgentQueueManager: Agent run with ID ${agentRunId} not found.`);
+                            return;
+                        }
+                        console.log("NotificationAgentQueueManager: Agent", agent);
+                        let updatedWorkflow;
+                        if (agentRun.status === "running" ||
+                            agentRun.status === "waiting_on_user") {
+                            if (agentRunId) {
+                                updatedWorkflow =
+                                    await this.advanceWorkflowStepOrCompleteAgentRun(agentRunId, agentRun.status, wsClientId, currentWorkflowStepIndex);
+                            }
+                            else {
+                                console.error(`NotificationAgentQueueManager: Agent run ID ${agentRunId} not found.`);
+                            }
+                            if (agent) {
+                                // Send notification
+                                await this.sendNotification(agent, agentRun, type, wsClientId, agentRun.status, returnvalue, agentRunId, updatedWorkflow);
+                            }
+                            else {
+                                console.error(`NotificationAgentQueueManager: Agent with ID ${agentId} not found.`);
+                            }
+                        }
+                        else if (agentRun.status === "stopped") {
+                            if (agentRunId) {
+                                updatedWorkflow = await this.goBackOneWorkflowStepIfNeeded(agentRunId, agentRun.status, wsClientId, currentWorkflowStepIndex);
+                            }
+                            else {
+                                console.error(`NotificationAgentQueueManager: Agent run ID ${agentRunId} not found.`);
+                            }
+                        }
+                        else {
+                            console.error(`NotificationAgentQueueManager: Agent run ${agentRunId} is not completed, status ${agentRun.status} but the job completed`);
+                        }
+                    }
+                    else {
+                        console.error(`NotificationAgentQueueManager: Job with ID ${jobId} not found.`);
+                    }
+                }
+                catch (error) {
+                    console.error(`NotificationAgentQueueManager: Error handling job completion for job ${jobId}:`, error);
+                }
+            });
+            queueEvents.on("failed", async ({ jobId, failedReason }) => {
+                console.log(`Job ${jobId} failed in queue ${queueName}. Reason:`, failedReason);
+                try {
+                    // Retrieve the job instance
+                    const job = await newQueue.getJob(jobId);
+                    if (job) {
+                        const { agentId, type, wsClientId, agentRunId } = job.data;
+                        console.log("NotificationAgentQueueManager: FAILED Job data", job.data);
+                        // Load the agent database record
+                        const agent = await PsAgent.findByPk(agentId, {
+                            include: [{ model: PsAgentClass, as: "Class" }],
+                        });
+                        const agentRun = await NotificationAgentQueueManager.getAgentRun(agentRunId);
+                        if (agent && agentRun) {
+                            // Send notification email
+                            //TODO: Fix this, the agent run should not be marked as failed if the job failed
+                            /*await this.sendNotification(
+                              agent,
+                              agentRun,
+                              type,
+                              wsClientId,
+                              "failed",
+                              failedReason,
+                              agentRunId,
+                              agentRun.workflow
+                            );*/
+                        }
+                        else {
+                            console.error(`NotificationAgentQueueManager: Agent with ID ${agentId} not found.`);
+                        }
+                        if (!agentRun) {
+                            console.error(`NotificationAgentQueueManager: Agent run with ID ${agentRunId} not found.`);
+                            return;
+                        }
+                        agentRun.workflow.steps[agentRun.workflow.currentStepIndex].endTime = new Date();
+                        //TODO: Fix this, the agent run should not be marked as failed if the job failed
+                        //agentRun.status = "failed";
+                        agentRun.changed("status", true);
+                        agentRun.changed("workflow", true);
+                        await agentRun.save();
+                    }
+                    else {
+                        console.error(`Job with ID ${jobId} not found.`);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error handling job failure for job ${jobId}:`, error);
+                }
+            });
+            queueEvents.on("progress", ({ jobId, data }) => {
+                console.log(`Job ${jobId} reported progress in queue ${queueName}:`, data);
+            });
+            queueEvents.on("removed", ({ jobId }) => {
+                console.log(`Job ${jobId} was removed from queue ${queueName}`);
+            });
+            queueEvents.on("drained", () => {
+                console.log(`Queue ${queueName} was drained`);
+            });
+            queueEvents.on("error", (error) => {
+                console.log(`Error in queue ${queueName}:`, error);
+            });
+            this.queues.set(queueName, newQueue);
+        }
+        return this.queues.get(queueName);
+    }
+    async controlAgent(agentId, action) {
+        console.log(`AgentQueueManager: Controlling agent ${agentId} with action ${action}`);
+        const agent = await PsAgent.findByPk(agentId, {
+            include: [{ model: PsAgentClass, as: "Class" }],
+        });
+        if (!agent || !agent.Class) {
+            console.error(`AgentQueueManager: Agent or Agent Class not found for agent ${agentId}`);
+            throw new Error("Agent or Agent Class not found");
+        }
+        const queueName = agent.Class.configuration.queueName;
+        if (!queueName) {
+            console.error(`AgentQueueManager: Queue name not defined for agent class ${agent.Class.id}`);
+            throw new Error("Queue name not defined for this agent class");
+        }
+        const queue = this.getQueue(queueName);
+        console.log(`AgentQueueManager: Adding ${action} job to queue ${queueName} for agent ${agentId}`);
+        await queue.add(`${action}Agent`, { agentId, action });
+        const message = `${action.charAt(0).toUpperCase() + action.slice(1)} request for agent ${agentId} queued in ${queueName}`;
+        console.log(`AgentQueueManager: ${message}`);
+        return message;
+    }
+    async startAgentProcessingWithWsClient(agentId, agentRunId, wsClientId, structuredAnswersOverrides) {
+        console.log(`NotificationAgentQueueManager: Starting agent processing for agent ${agentId}`);
+        const agent = await PsAgent.findByPk(agentId, {
+            include: [{ model: PsAgentClass, as: "Class" }],
+        });
+        if (!agent || !agent.Class) {
+            console.error(`NotificationAgentQueueManager: Agent or Agent Class not found for agent ${agentId}`);
+            return undefined;
+        }
+        const agentRun = await NotificationAgentQueueManager.getAgentRun(agentRunId);
+        if (!agentRun) {
+            console.error(`NotificationAgentQueueManager: Agent run with ID ${agentRunId} not found.`);
+            return undefined;
+        }
+        const currentWorkflow = agentRun.workflow;
+        const queueName = agent.Class.configuration.queueName;
+        const queue = this.getQueue(queueName);
+        console.log(`NotificationAgentQueueManager: Adding start-processing job to queue ${queueName} for agent ${agentId}`);
+        const action = "start";
+        const job = await queue.add("control-message", {
+            type: `${action}Agent${agent.id}`,
+            agentId: agent.id,
+            action: action,
+            wsClientId: wsClientId,
+            agentRunId: agentRunId,
+            structuredAnswersOverrides: structuredAnswersOverrides,
+            currentWorkflowStepIndex: currentWorkflow.currentStepIndex,
+        });
+        console.log(`NotificationAgentQueueManager: Updating agent ${agentId} status to running`);
+        await this.updateAgentStatus(agent.id, "running");
+        return job.id;
+    }
+    async stopAgentProcessing(agentId, wsClientId, agentRunId) {
+        console.log(`NotificationAgentQueueManager: Stopping agent processing for agent ${agentId}`);
+        const agent = await PsAgent.findByPk(agentId, {
+            include: [{ model: PsAgentClass, as: "Class" }],
+        });
+        if (!agent || !agent.Class) {
+            throw Error(`NotificationAgentQueueManager: Agent or Agent Class not found for agent ${agentId}`);
+        }
+        const agentRun = await NotificationAgentQueueManager.getAgentRun(agentRunId);
+        if (!agentRun) {
+            console.error(`NotificationAgentQueueManager: Agent run with ID ${agentRunId} not found.`);
+            return false;
+        }
+        const currentWorkflow = agentRun.workflow;
+        const queueName = agent.Class.configuration.queueName;
+        const queue = this.getQueue(queueName);
+        const action = "stop";
+        console.log(`NotificationAgentQueueManager: Adding stop-processing job to queue ${queueName} for agent ${agentId} ${action}`);
+        await queue.add("control-message", {
+            type: `${action}Agent${agent.id}`,
+            agentId: agent.id,
+            action: action,
+            wsClientId: wsClientId,
+            agentRunId: agentRunId,
+            currentWorkflowStepIndex: currentWorkflow.currentStepIndex,
+        });
+        await this.updateAgentStatus(agent.id, "stopped");
+        return true;
+    }
+    async getAgentStatus(agentId) {
+        const agent = await PsAgent.findByPk(agentId, {
+            include: [{ model: PsAgentClass, as: "Class" }],
+        });
+        if (agent) {
+            const statusDataString = await this.redisClient.get(agent.redisStatusKey);
+            if (statusDataString) {
+                const statusData = JSON.parse(statusDataString);
+                return statusData;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    async updateAgentStatus(agentId, state, progress, message, details) {
+        const agent = await PsAgent.findByPk(agentId, {
+            include: [{ model: PsAgentClass, as: "Class" }],
+        });
+        if (agent) {
+            const statusDataString = await this.redisClient.get(agent.redisStatusKey);
+            if (statusDataString) {
+                const statusData = JSON.parse(statusDataString);
+                statusData.state = state;
+                statusData.lastUpdated = Date.now();
+                if (progress !== undefined)
+                    statusData.progress = progress;
+                if (message)
+                    statusData.messages.push(message);
+                if (details)
+                    statusData.details = {
+                        ...statusData.details,
+                        ...details,
+                    };
+                await this.redisClient.set(agent.redisStatusKey, JSON.stringify(statusData));
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+}