@yrpri/api 9.0.99 → 9.0.101

package/agents/assistants/modes/tools/workflowTools.js

@@ -0,0 +1,112 @@
+import { BaseAssistantTools } from "./baseTools.js";
+export class WorkflowTools extends BaseAssistantTools {
+    constructor(assistant) {
+        super(assistant);
+    }
+    get show_running_workflow_conversations() {
+        return {
+            name: "show_running_workflow_conversations",
+            description: "Display running workflow conversations",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: []
+            },
+            handler: this.showRunningWorkflowsHandler.bind(this)
+        };
+    }
+    async showRunningWorkflowsHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: show_running_workflows: ${JSON.stringify(params, null, 2)}`);
+        try {
+            const html = `<yp-workflow-widget-small running="true"></yp-workflow-widget-small>`;
+            return {
+                success: true,
+                html,
+                uniqueToken: "runningWorkflows",
+                data: { message: "Running workflows displayed successfully" },
+                metadata: { timestamp: new Date().toISOString() }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Error displaying running workflows";
+            console.error(`Error in show_running_workflows: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    get show_all_workflow_conversations() {
+        return {
+            name: "show_all_workflow_conversations",
+            description: "Display all workflow conversations",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: []
+            },
+            handler: this.showAllWorkflowsHandler.bind(this)
+        };
+    }
+    async showAllWorkflowsHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: show_all_workflows: ${JSON.stringify(params, null, 2)}`);
+        try {
+            const html = `<yp-workflow-widget-small all="true"></yp-workflow-widget-small>`;
+            return {
+                success: true,
+                html,
+                uniqueToken: "allWorkflows",
+                data: { message: "All workflows displayed successfully" },
+                metadata: { timestamp: new Date().toISOString() }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Error displaying all workflows";
+            console.error(`Error in show_all_workflows: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    get connect_to_workflow_conversation() {
+        return {
+            name: "connect_to_workflow_conversation",
+            description: "Connect to an existing workflow conversation",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {
+                    workflowId: { type: "number" }
+                },
+                required: ["workflowId"]
+            },
+            handler: this.connectToWorkflowHandler.bind(this)
+        };
+    }
+    async connectToWorkflowHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: connect_to_workflow: ${JSON.stringify(params, null, 2)}`);
+        try {
+            const { workflowId } = params;
+            return {
+                success: true,
+                data: { message: `Connected to workflow ${workflowId} successfully` },
+                uniqueToken: `connectWorkflow_${workflowId}`,
+                metadata: { timestamp: new Date().toISOString() }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Error connecting to workflow conversation";
+            console.error(`Error in connect_to_workflow_conversation: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+}

package/agents/assistants/voiceAssistant.js

@@ -82,7 +82,7 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
             throw new Error("No subscription plan found");
         }
         if (subscriptionPlan?.AgentProduct.name) {
-            this.exitMessageFromDirectAgentConversation = `Welcome the user back from their conversation with the ${subscriptionPlan.AgentProduct.name}. (it happened on a seperate channel). Now help the user with agent selection and subscription management.`;
+            this.exitMessageFromDirectAgentConversation = `Welcome the user back from their conversation with the ${subscriptionPlan.AgentProduct.name}. (it happened on a seperate channel). Now help the user with agent selection`;
         }
         this.sendToClient("assistant", "", "clear_audio_buffer");
         if (this.directAgentVoiceConnection) {
@@ -132,7 +132,7 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
             this.directAgentVoiceConnection = undefined;
             this.parentAssistant.memory.chatLog.push({
                 sender: "user",
-                message: "Thank you for the information, I would now like to speak to the main assistant about selecting agents or managing subscriptions",
+                message: "Thank you for the information, I would now like to speak to the main assistant about selecting agents",
             });
             await this.parentAssistant.saveMemory();
         }
@@ -189,7 +189,7 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
                         await this.handleSpeechStopped();
                         break;
                     case "response.cancelled":
-                        console.log("-------------------MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMZZZZZZZZZZZZZZ>>>>>>>>>>>>>>>>>>> response.cancelled");
+                        console.log("response.cancelled");
                         this.isWaitingOnCancelResponseCompleted = false;
                         break;
                     case "conversation.item.input_audio_transcription.completed":

package/agents/controllers/assistantsController.js

@@ -14,6 +14,7 @@ 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,
@@ -65,7 +66,7 @@ export class AssistantController {
                 }
                 const markdownContent = match[1];
                 const htmlContent = await marked(markdownContent);
-                const docxBuffer = await HTMLtoDOCX(htmlContent);
+                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"');
@@ -121,7 +122,7 @@ export class AssistantController {
                 const subscription = await YpSubscription.findOne({
                     where: {
                         id: subscriptionId,
-                        user_id: req.user.id
+                        user_id: req.user.id,
                     },
                 });
                 if (!subscription) {
@@ -335,8 +336,62 @@ export class AssistantController {
                 res.send({});
             }
         };
+        // 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();
     }
@@ -355,6 +410,9 @@ export class AssistantController {
         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);

package/agents/managers/newAiModelSetup.js

@@ -84,6 +84,37 @@ export class NewAiModelSetup {
             console.log("Anthropic model already exists: Anthropic Sonnet 3.5");
         }
     }
+    static async seedAnthropic37Models(userId) {
+        const anthropicSonnet = await PsAiModel.findOne({
+            where: { name: "Anthropic Sonnet 3.7" },
+        });
+        const anthropicSonnetConfig = {
+            type: PsAiModelType.TextReasoning,
+            modelSize: PsAiModelSize.Medium,
+            provider: "anthropic",
+            prices: {
+                costInTokensPerMillion: 3,
+                costOutTokensPerMillion: 15,
+                currency: "USD",
+            },
+            maxTokensOut: 8000,
+            defaultTemperature: 0.7,
+            model: "claude-3-7-sonnet-20250219",
+            active: true,
+        };
+        if (!anthropicSonnet) {
+            const createdModel = await PsAiModel.create({
+                name: "Anthropic Sonnet 3.7",
+                organization_id: 1,
+                user_id: userId,
+                configuration: anthropicSonnetConfig,
+            });
+            console.log("Created Anthropic model:", createdModel);
+        }
+        else {
+            console.log("Anthropic model already exists: Anthropic Sonnet 3.7");
+        }
+    }
     /**
      * Seeds OpenAI models.
      * This currently creates several models including GPT-4o, GPT-4o Mini, o1 Mini,
@@ -276,6 +307,35 @@ export class NewAiModelSetup {
         else {
             console.log("OpenAI model already exists: o3 mini");
         }
+        const openAiGpt45 = await PsAiModel.findOne({
+            where: { name: "GPT-4.5 Preview" },
+        });
+        const openAiGpt45Config = {
+            type: PsAiModelType.Text,
+            modelSize: PsAiModelSize.Large,
+            provider: "openai",
+            prices: {
+                costInTokensPerMillion: 75,
+                costOutTokensPerMillion: 150,
+                currency: "USD",
+            },
+            maxTokensOut: 100000,
+            defaultTemperature: 0.7,
+            model: "gpt-4.5-preview",
+            active: true,
+        };
+        if (!openAiGpt45) {
+            await PsAiModel.create({
+                name: "GPT-4.5 Preview",
+                organization_id: 1,
+                user_id: userId,
+                configuration: openAiGpt45Config,
+            });
+            console.log("Created OpenAI model: GPT-4.5 Preview");
+        }
+        else {
+            console.log("OpenAI model already exists: GPT-4.5 Preview updating");
+        }
     }
     /**
      * Seeds Google models.
@@ -380,6 +440,7 @@ export class NewAiModelSetup {
     static async seedAiModels(userId) {
         try {
             await NewAiModelSetup.seedAnthropicModels(userId);
+            await NewAiModelSetup.seedAnthropic37Models(userId);
             await NewAiModelSetup.seedOpenAiModels(userId);
             await NewAiModelSetup.seedGoogleModels(userId);
             // Optionally, seed the top-level agent class if it does not exist.
@@ -461,8 +522,10 @@ export class NewAiModelSetup {
         // Explicitly type envKey as a key of apiKeys
         const modelsMapping = [
             { name: "Anthropic Sonnet 3.5", envKey: "ANTHROPIC_CLAUDE_API_KEY" },
+            { name: "Anthropic Sonnet 3.7", envKey: "ANTHROPIC_CLAUDE_API_KEY" },
             { name: "GPT-4o", envKey: "OPENAI_API_KEY" },
             { name: "GPT-4o Mini", envKey: "OPENAI_API_KEY" },
+            { name: "GPT-4.5 Preview", envKey: "OPENAI_API_KEY" },
             { name: "o1 Preview", envKey: "OPENAI_API_KEY" },
             { name: "o1 Mini", envKey: "OPENAI_API_KEY" },
             { name: "Gemini 1.5 Pro 2", envKey: "GEMINI_API_KEY" },

package/agents/managers/notificationAgentQueueManager.js

@@ -27,13 +27,18 @@ export class NotificationAgentQueueManager extends AgentQueueManager {
         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 },
+                updatedWorkflow: {
+                    workflow: updatedWorkflow,
+                    status: status,
+                    currentWorkflowStep,
+                },
             }));
         }
         else {

package/agents/managers/workflowConversationManager.js

@@ -0,0 +1,79 @@
+import { YpWorkflowConversation } from "../models/workflowConversation.js";
+export class WorkflowConversationManager {
+    constructor() { }
+    async createWorkflowConversation(data) {
+        try {
+            const workflow = await YpWorkflowConversation.create({
+                agentProductId: data.agentProductId,
+                userId: data.userId || null,
+                configuration: data.configuration || {},
+            });
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Error creating workflow conversation: ${error.message}`);
+        }
+    }
+    async getWorkflowConversation(workflowConversationId) {
+        try {
+            const workflowConversation = await YpWorkflowConversation.findByPk(workflowConversationId);
+            return workflowConversation;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving workflow conversation: ${error.message}`);
+        }
+    }
+    async updateWorkflowConversation(workflowConversationId, updates) {
+        try {
+            const workflowConversation = await YpWorkflowConversation.findByPk(workflowConversationId);
+            if (!workflowConversation) {
+                throw new Error("Workflow conversation not found");
+            }
+            Object.assign(workflowConversation, updates);
+            await workflowConversation.save();
+            return workflowConversation;
+        }
+        catch (error) {
+            throw new Error(`Error updating workflow conversation: ${error.message}`);
+        }
+    }
+    async connectToWorkflowConversation(workflowConversationId, connectionData) {
+        try {
+            const workflowConversation = await YpWorkflowConversation.findByPk(workflowConversationId);
+            if (!workflowConversation) {
+                throw new Error("Workflow conversation not found");
+            }
+            workflowConversation.configuration = {
+                ...workflowConversation.configuration,
+                ...connectionData,
+            };
+            await workflowConversation.save();
+            return workflowConversation;
+        }
+        catch (error) {
+            throw new Error(`Error connecting to workflow: ${error.message}`);
+        }
+    }
+    async getWorkflowConversationsForUser(userId) {
+        try {
+            const workflowConversations = await YpWorkflowConversation.findAll({ where: { userId } });
+            return workflowConversations;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving workflow conversations for user ${userId}: ${error.message}`);
+        }
+    }
+    async getRunningWorkflowConversationsForUser(userId) {
+        try {
+            const allWorkflowConversations = await this.getWorkflowConversationsForUser(userId);
+            const runningWorkflowConversations = allWorkflowConversations.filter((workflowConversation) => {
+                return (workflowConversation.configuration &&
+                    workflowConversation.configuration.running === true);
+            });
+            return runningWorkflowConversations;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving running workflows for user ${userId}: ${error.message}`);
+        }
+    }
+}

package/agents/managers/workflowManager.js

@@ -0,0 +1,76 @@
+import { YpWorkflowConversation } from "../models/workflowConverstation.js";
+export class WorkflowManager {
+    constructor() { }
+    async createWorkflow(data) {
+        try {
+            const workflow = await YpWorkflowConversation.create({
+                agentProductId: data.agentProductId,
+                userId: data.userId || null,
+                configuration: data.configuration || {},
+            });
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Error creating workflow: ${error.message}`);
+        }
+    }
+    async getWorkflow(workflowId) {
+        try {
+            const workflow = await YpWorkflowConversation.findByPk(workflowId);
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving workflow: ${error.message}`);
+        }
+    }
+    async updateWorkflow(workflowId, updates) {
+        try {
+            const workflow = await YpWorkflowConversation.findByPk(workflowId);
+            if (!workflow) {
+                throw new Error("Workflow not found");
+            }
+            Object.assign(workflow, updates);
+            await workflow.save();
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Error updating workflow: ${error.message}`);
+        }
+    }
+    async connectToWorkflow(workflowId, connectionData) {
+        try {
+            const workflow = await YpWorkflowConversation.findByPk(workflowId);
+            if (!workflow) {
+                throw new Error("Workflow not found");
+            }
+            workflow.configuration = { ...workflow.configuration, ...connectionData };
+            await workflow.save();
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Error connecting to workflow: ${error.message}`);
+        }
+    }
+    async getWorkflowsForUser(userId) {
+        try {
+            const workflows = await YpWorkflowConversation.findAll({ where: { userId } });
+            return workflows;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving workflows for user ${userId}: ${error.message}`);
+        }
+    }
+    async getRunningWorkflowsForUser(userId) {
+        try {
+            const allWorkflows = await this.getWorkflowsForUser(userId);
+            const runningWorkflows = allWorkflows.filter((workflow) => {
+                return (workflow.configuration &&
+                    workflow.configuration.running === true);
+            });
+            return runningWorkflows;
+        }
+        catch (error) {
+            throw new Error(`Error retrieving running workflows for user ${userId}: ${error.message}`);
+        }
+    }
+}

package/agents/models/agentProduct.js

@@ -33,9 +33,13 @@ YpAgentProduct.init({
         type: DataTypes.INTEGER,
         allowNull: false,
     },
+    parent_agent_product_id: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+    },
     configuration: {
         type: DataTypes.JSONB,
-        allowNull: false
+        allowNull: false,
     },
     status: {
         type: DataTypes.JSONB,
@@ -54,12 +58,13 @@ YpAgentProduct.init({
     },
 }, {
     sequelize,
-    tableName: 'agent_products',
+    tableName: "agent_products",
     indexes: [
-        { fields: ['uuid'], unique: true },
-        { fields: ['user_id'] },
-        { fields: ['group_id'] },
-        { fields: ['domain_id'] },
+        { fields: ["uuid"], unique: true },
+        { fields: ["user_id"] },
+        { fields: ["group_id"] },
+        { fields: ["domain_id"] },
+        { fields: ["parent_agent_product_id"] },
     ],
     timestamps: true,
     underscored: true,
@@ -67,37 +72,45 @@ YpAgentProduct.init({
 YpAgentProduct.associate = (models) => {
     console.log(`YpAgentProduct.associate`);
     YpAgentProduct.belongsTo(models.YpSubscriptionUser, {
-        foreignKey: 'user_id',
-        as: 'User'
+        foreignKey: "user_id",
+        as: "User",
     });
     YpAgentProduct.belongsTo(models.Group, {
-        foreignKey: 'group_id',
-        as: 'Group'
+        foreignKey: "group_id",
+        as: "Group",
     });
     YpAgentProduct.hasOne(models.YpAgentProductBundle, {
-        foreignKey: 'agent_bundle_id',
-        as: 'AgentBundle'
+        foreignKey: "agent_bundle_id",
+        as: "AgentBundle",
     });
     YpAgentProduct.hasMany(models.YpAgentProductBoosterPurchase, {
-        foreignKey: 'agent_product_id',
-        as: 'BoosterPurchases',
+        foreignKey: "agent_product_id",
+        as: "BoosterPurchases",
     });
     YpAgentProduct.hasMany(models.YpSubscription, {
-        foreignKey: 'agent_product_id',
-        as: 'Subscriptions',
+        foreignKey: "agent_product_id",
+        as: "Subscriptions",
     });
     YpAgentProduct.hasMany(models.YpSubscriptionPlan, {
-        foreignKey: 'agent_product_id',
-        as: 'SubscriptionPlans',
+        foreignKey: "agent_product_id",
+        as: "SubscriptionPlans",
     });
     YpAgentProduct.hasMany(models.YpAgentProductRun, {
-        foreignKey: 'agent_product_id',
-        as: 'Runs',
+        foreignKey: "agent_product_id",
+        as: "Runs",
     });
     YpAgentProduct.belongsToMany(models.YpAgentProductBundle, {
-        through: 'agent_product_bundles_products',
-        foreignKey: 'agent_product_id',
-        otherKey: 'agent_product_bundle_id',
-        as: 'AgentBundles'
+        through: "agent_product_bundles_products",
+        foreignKey: "agent_product_id",
+        otherKey: "agent_product_bundle_id",
+        as: "AgentBundles",
+    });
+    YpAgentProduct.belongsTo(YpAgentProduct, {
+        as: "ParentAgentProduct",
+        foreignKey: "parent_agent_product_id",
+    });
+    YpAgentProduct.hasMany(YpAgentProduct, {
+        as: "ChildAgentProducts",
+        foreignKey: "parent_agent_product_id",
     });
 };

package/agents/models/agentProductRun.js

@@ -10,6 +10,7 @@ YpAgentProductRun.init({
     start_time: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
     end_time: { type: DataTypes.DATE, allowNull: true },
     duration: { type: DataTypes.INTEGER, allowNull: true },
+    parent_agent_product_run_id: { type: DataTypes.INTEGER, allowNull: true },
     status: {
         type: DataTypes.STRING,
         allowNull: false,
@@ -40,4 +41,12 @@ YpAgentProductRun.associate = (models) => {
         foreignKey: 'subscription_id',
         as: 'Subscription',
     });
+    YpAgentProductRun.belongsTo(models.YpAgentProductRun, {
+        foreignKey: 'parent_agent_product_run_id',
+        as: 'ParentAgentProduct',
+    });
+    YpAgentProductRun.hasMany(models.YpAgentProductRun, {
+        foreignKey: 'parent_agent_product_run_id',
+        as: 'ChildAgentProducts',
+    });
 };