@yrpri/api 9.0.101 → 9.0.103

package/dist/agents/assistants/modes/tools/models/agents.js

@@ -0,0 +1,146 @@
+import { NotificationAgentQueueManager } from "../../../../managers/notificationAgentQueueManager.js";
+import { YpAgentProductRun } from "../../../../models/agentProductRun.js";
+import { SubscriptionModels } from "./subscriptions.js";
+export class AgentModels {
+    constructor(assistant) {
+        this.assistant = assistant;
+        this.subscriptionModels = new SubscriptionModels(assistant);
+        this.queueManager = new NotificationAgentQueueManager(this.assistant.wsClients);
+    }
+    async getCurrentAgentAndWorkflow() {
+        const agent = await this.assistant.getCurrentAgentProduct();
+        const currentRun = await this.assistant.getCurrentAgentRun();
+        if (!currentRun && !agent) {
+            throw new Error("No agent or run found");
+        }
+        else if (!currentRun) {
+            return {
+                agent: agent,
+                run: undefined,
+            };
+        }
+        else {
+            return {
+                agent: agent,
+                run: currentRun,
+            };
+        }
+    }
+    convertToUnderscoresWithMaxLength(str) {
+        const converted = str
+            .replace(/\s+/g, "_") // Replace spaces with underscores
+            .replace(/([A-Z])/g, "_$1") // Add underscore before capital letters
+            .replace(/^_/, "") // Remove leading underscore
+            .replace(/-/g, "_") // Replace hyphens with underscores
+            .replace(/_+/g, "_") // Replace multiple underscores with single
+            .toLowerCase();
+        return converted.length > 34 ? converted.slice(0, 34) : converted;
+    }
+    async startCurrentWorkflowStep(agentRunId, structuredAnswersOverrides) {
+        try {
+            const agentRunToUpdate = await YpAgentProductRun.findByPk(agentRunId);
+            if (!agentRunToUpdate) {
+                throw new Error("Agent run not found");
+            }
+            if (!this.assistant.memory.currentAgentStatus?.subscriptionId) {
+                throw new Error("No active subscription found for this agent");
+            }
+            const workflow = agentRunToUpdate.workflow;
+            const totalSteps = workflow.steps.length;
+            let currentStepIndex = workflow.currentStepIndex;
+            let currentStep = workflow.steps[currentStepIndex];
+            const isLastStep = currentStepIndex >= totalSteps - 1;
+            console.log(`oldStep: ${JSON.stringify(currentStep, null, 2)}`);
+            if (currentStep.type !== "agentOps" && !isLastStep) {
+                workflow.currentStepIndex++;
+                currentStepIndex = workflow.currentStepIndex;
+                currentStep = workflow.steps[currentStepIndex];
+            }
+            currentStep.startTime = new Date();
+            console.log(`newStep: ${JSON.stringify(currentStep, null, 2)}`);
+            if (currentStepIndex >= totalSteps) {
+                throw new Error(`Agent run ${agentRunId} is already at the last step of the workflow`);
+            }
+            const agentId = currentStep.agentId;
+            if (!agentId) {
+                throw new Error("No agent ID found in the current step");
+            }
+            // Start processing with websocket client ID
+            const jobId = await this.queueManager.startAgentProcessingWithWsClient(agentId, agentRunId, this.assistant.wsClientId, structuredAnswersOverrides);
+            if (!jobId) {
+                throw new Error("Failed to start agent processing");
+            }
+            workflow.steps[currentStepIndex].queueJobId = jobId;
+            agentRunToUpdate.status = "running";
+            agentRunToUpdate.changed("workflow", true);
+            await agentRunToUpdate.save();
+            return {
+                agentRun: agentRunToUpdate,
+                previousStep: currentStep,
+                currentStep: workflow.steps[currentStepIndex],
+                message: "Agent workflow started successfully",
+            };
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error("Error starting agent workflow step");
+        }
+    }
+    async getCurrentWorkflowStep() {
+        const agentRun = await this.getCurrentAgentAndWorkflow();
+        return agentRun.run.workflow.steps[agentRun.run.workflow.currentStepIndex];
+    }
+    async getNextWorkflowStep() {
+        const agentRun = await this.getCurrentAgentAndWorkflow();
+        if (!agentRun.run) {
+            return undefined;
+        }
+        //TODO: look into this deal with the difference between agentOps and engagment
+        if (agentRun.run.workflow.currentStepIndex === 0) {
+            return agentRun.run.workflow.steps[0];
+        }
+        if (agentRun.run.workflow.currentStepIndex >=
+            agentRun.run.workflow.steps.length - 1) {
+            return undefined;
+        }
+        return agentRun.run.workflow.steps[agentRun.run.workflow.currentStepIndex + 1];
+    }
+    async stopCurrentWorkflowStep() {
+        console.log("---------------------> stopCurrentWorkflowStep");
+        const agent = await this.assistant.getCurrentAgentProduct();
+        const currentRun = (await YpAgentProductRun.findByPk(this.assistant.memory.currentAgentStatus?.activeAgentRunId));
+        if (!currentRun) {
+            throw new Error("No active workflow found to stop");
+        }
+        const currentStep = currentRun.workflow.steps[currentRun.workflow.currentStepIndex];
+        if (!agent) {
+            throw new Error("No agent found");
+        }
+        if (!currentStep.agentId) {
+            throw new Error("No agent ID found in the current step");
+        }
+        // Stop processing using queue manager
+        await this.queueManager.stopAgentProcessing(currentStep.agentId, this.assistant.wsClientId, currentRun.id);
+        // Update run status
+        currentRun.status = "stopped";
+        currentRun.end_time = new Date();
+        await currentRun.save();
+        // Get current status from queue manager
+        const queueStatus = await this.queueManager.getAgentStatus(agent.id);
+        if (queueStatus) {
+            console.log(`Current queue status for agent ${agent.id}:`, queueStatus);
+        }
+        return {
+            agent,
+            run: currentRun,
+            message: "Agent workflow stopped successfully",
+        };
+    }
+    async checkAgentStatus() {
+        const agent = await this.assistant.getCurrentAgentProduct();
+        if (!agent) {
+            throw new Error("No agent found");
+        }
+        return this.queueManager.getAgentStatus(agent.id);
+    }
+}

package/dist/agents/assistants/modes/tools/models/subscriptions.js

@@ -0,0 +1,332 @@
+import { YpSubscription } from "../../../../models/subscription.js";
+import { YpSubscriptionPlan } from "../../../../models/subscriptionPlan.js";
+import { YpAgentProduct } from "../../../../models/agentProduct.js";
+import { YpAgentProductBundle } from "../../../../models/agentProductBundle.js";
+import { YpAgentProductRun } from "../../../../models/agentProductRun.js";
+import { Op } from "sequelize";
+export class SubscriptionModels {
+    constructor(assistant) {
+        this.assistant = assistant;
+    }
+    async loadAgentSubscriptionPlans() {
+        try {
+            const firstBundle = await YpAgentProductBundle.findOne({
+                where: {
+                //TODO: get working
+                //domain_id: this.domainId,
+                },
+            });
+            // Get all available subscription plans with their associated agent products
+            const availablePlans = await YpSubscriptionPlan.findAll({
+                where: {
+                    id: {
+                        [Op.in]: [1, 6],
+                    },
+                    //  status: 'active', // Only get active plans
+                },
+                attributes: ['id', 'configuration', 'name', 'description'],
+                include: [
+                    {
+                        model: YpAgentProduct,
+                        as: "AgentProduct",
+                        attributes: {
+                            exclude: ["created_at", "updated_at"],
+                        },
+                        include: [
+                            {
+                                model: YpAgentProductBundle,
+                                as: "AgentBundles",
+                                required: false,
+                                attributes: {
+                                    exclude: ["created_at", "updated_at"],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+            console.log(`-----------XXXXXXXXXXXXXXXx----------_> ${JSON.stringify(availablePlans, null, 2)}`);
+            return {
+                availablePlans: availablePlans.map((plan) => ({
+                    subscriptionPlanId: plan.id,
+                    type: plan.configuration?.type || "coming_soon",
+                    name: plan.AgentProduct?.configuration?.displayName || "No name available",
+                    description: plan.AgentProduct?.description || "No description available",
+                    imageUrl: plan.configuration?.imageUrl || "",
+                    // price: plan.configuration?.amount || 0,
+                    // currency: plan.configuration?.currency || "USD",
+                    // maxRunsPerCycle: plan.configuration?.max_runs_per_cycle || 0,
+                })),
+                availableBundle: firstBundle
+                    ? {
+                        agentBundleId: firstBundle.id,
+                        name: firstBundle.name,
+                        description: firstBundle.description || "",
+                        imageUrl: firstBundle.configuration?.imageUrl || "",
+                    }
+                    : "No bundle available",
+                systemStatus: {
+                    healthy: true,
+                    lastUpdated: new Date(),
+                },
+            };
+        }
+        catch (error) {
+            console.error("Error loading available subscription plans:", error);
+            return {
+                availablePlans: [],
+                availableBundle: "No bundle available",
+                systemStatus: {
+                    healthy: false,
+                    lastUpdated: new Date(),
+                    error: error instanceof Error ? error.message : "Unknown error",
+                },
+            };
+        }
+    }
+    async loadAgentProductPlanAndSubscription(subscriptionPlanId) {
+        const plan = (await YpSubscriptionPlan.findOne({
+            where: {
+                id: subscriptionPlanId,
+            },
+            include: [
+                {
+                    model: YpAgentProduct,
+                    as: "AgentProduct",
+                },
+            ],
+        }));
+        if (!plan) {
+            throw new Error(`Agent product with id ${subscriptionPlanId} not found`);
+        }
+        let subscription = null;
+        if (this.assistant.memory.currentUser) {
+            subscription = (await YpSubscription.findOne({
+                where: {
+                    subscription_plan_id: subscriptionPlanId,
+                    status: "active",
+                    user_id: this.assistant.memory.currentUser?.id,
+                },
+                include: [
+                    {
+                        model: YpSubscriptionPlan,
+                        as: "Plan",
+                        attributes: ['id', 'configuration'],
+                    },
+                ],
+            }));
+        }
+        return { subscription, plan };
+    }
+    async loadUserAgentSubscriptions() {
+        try {
+            // Get available agent products from user's subscriptions for their domain
+            const availableSubscriptions = await YpSubscription.findAll({
+                where: {
+                    user_id: this.assistant.memory.currentUser?.id,
+                    domain_id: this.assistant.domainId,
+                    status: "active",
+                },
+                include: [
+                    {
+                        model: YpSubscriptionPlan,
+                        as: "Plan",
+                        include: [
+                            {
+                                model: YpAgentProduct,
+                                as: "AgentProduct",
+                            },
+                        ],
+                    },
+                    {
+                        model: YpAgentProduct,
+                        as: "AgentProduct",
+                        attributes: {
+                            exclude: ["created_at", "updated_at"],
+                        },
+                        include: [
+                            {
+                                model: YpAgentProductBundle,
+                                as: "AgentBundles",
+                                required: false,
+                                attributes: {
+                                    exclude: ["created_at", "updated_at"],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+            // Get currently running agents for the domain
+            const runningAgents = await YpAgentProductRun.findAll({
+                where: {
+                    //domain_id: this.domainId, //TODO: get working
+                    status: "running",
+                },
+                include: [
+                    {
+                        model: YpSubscription,
+                        as: "Subscription",
+                        where: {
+                            domain_id: this.assistant.domainId,
+                            status: "active",
+                        },
+                        include: [
+                            {
+                                model: YpAgentProduct,
+                                as: "AgentProduct",
+                            },
+                            {
+                                model: YpSubscriptionPlan,
+                                as: "Plan",
+                            },
+                        ],
+                    },
+                ],
+            });
+            return {
+                availableSubscriptions: availableSubscriptions,
+                runningAgents: runningAgents.map((run) => ({
+                    runId: run.id,
+                    agentProductId: run.Subscription?.AgentProduct?.id || 0,
+                    agentRunId: run.id,
+                    agentName: run.Subscription?.AgentProduct?.name || "",
+                    startTime: run.start_time,
+                    status: run.status,
+                    workflow: run.workflow,
+                    subscriptionId: run.subscription_id,
+                })),
+                systemStatus: {
+                    healthy: true,
+                    lastUpdated: new Date(),
+                },
+            };
+        }
+        catch (error) {
+            console.error("Error loading agent status:", error);
+            return {
+                availableSubscriptions: [],
+                runningAgents: [],
+                systemStatus: {
+                    healthy: false,
+                    lastUpdated: new Date(),
+                    error: error instanceof Error ? error.message : "Unknown error",
+                },
+            };
+        }
+    }
+    async unsubscribeFromAgentPlan(subscriptionId) {
+        try {
+            const subscription = await YpSubscription.findOne({
+                where: {
+                    id: subscriptionId,
+                    user_id: this.assistant.memory.currentUser?.id,
+                    domain_id: this.assistant.domainId,
+                    status: "active",
+                },
+            });
+            if (!subscription) {
+                return {
+                    success: false,
+                    error: "Subscription not found or already inactive",
+                };
+            }
+            const userId = this.assistant.memory.currentUser?.id;
+            subscription.status = "cancelled";
+            subscription.configuration = {
+                cancelledAt: new Date(),
+                cancelledByUserId: userId,
+            };
+            subscription.end_date = new Date();
+            subscription.changed("configuration", true);
+            await subscription.save();
+            return {
+                success: true,
+                subscriptionId: subscription.id,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : "Failed to unsubscribe from agent plan";
+            console.error(`Database error in unsubscribeFromAgentPlan: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async subscribeToAgentPlan(agentProductId, subscriptionPlanId, returnCurrentSubscription = false) {
+        try {
+            const plan = await YpSubscriptionPlan.findOne({
+                where: {
+                    id: subscriptionPlanId,
+                },
+                include: [
+                    {
+                        model: YpAgentProduct,
+                        as: "AgentProduct",
+                    },
+                ],
+            });
+            if (!plan) {
+                return {
+                    success: false,
+                    error: "Subscription plan not found",
+                };
+            }
+            const userId = this.assistant.memory.currentUser?.id;
+            if (!userId) {
+                return {
+                    success: false,
+                    error: "User not found",
+                };
+            }
+            const existingSubscription = await YpSubscription.findOne({
+                where: {
+                    subscription_plan_id: subscriptionPlanId,
+                    user_id: userId,
+                },
+            });
+            if (returnCurrentSubscription && existingSubscription) {
+                return {
+                    success: true,
+                    plan: plan,
+                    subscription: existingSubscription,
+                };
+            }
+            else if (existingSubscription) {
+                return {
+                    success: false,
+                    error: "User already subscribed to this plan",
+                };
+            }
+            console.log(`-------> subscribing to agent plan ${subscriptionPlanId} for user ${userId}`);
+            const subscription = await YpSubscription.create({
+                subscription_plan_id: subscriptionPlanId,
+                agent_product_id: agentProductId,
+                user_id: userId,
+                domain_id: this.assistant.domainId,
+                next_billing_date: new Date(),
+                status: "active",
+                start_date: new Date(),
+                configuration: plan.configuration,
+            });
+            return {
+                success: true,
+                plan: plan,
+                subscription: subscription,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : "Failed to subscribe to agent plan";
+            console.error(`Database error in subscribeToAgentPlan: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+}

package/dist/agents/assistants/modes/tools/models/users.js

@@ -0,0 +1,11 @@
+export class UserModels {
+    constructor(assistant) {
+        this.assistant = assistant;
+    }
+    async loginUser() {
+        //TODO: implement actual login logic
+    }
+    async logoutUser() {
+        //TODO: implement actual logout logic
+    }
+}

package/dist/agents/assistants/modes/tools/navigationTools.js

@@ -0,0 +1,166 @@
+// commonTools.ts
+import { AgentModels } from "./models/agents.js";
+import { SubscriptionModels } from "./models/subscriptions.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export class NavigationTools extends BaseAssistantTools {
+    constructor(assistant) {
+        super(assistant);
+        this.agentModels = new AgentModels(assistant);
+        this.subscriptionModels = new SubscriptionModels(assistant);
+    }
+    async goBackToMainAssistant() {
+        await this.assistant.handleModeSwitch("agent_selection_mode", "User requested to return to the main assistant", {});
+        return {
+            success: true,
+            data: { message: "Returned to main assistant" },
+        };
+    }
+    get connectDirectlyToAgent() {
+        return {
+            name: "connect_directly_to_one_of_the_agents",
+            description: "Select an agent to work with. The user needs to be logged in to use this tool.",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {
+                    subscriptionPlanId: { type: "number" },
+                },
+                required: [
+                    "subscriptionPlanId",
+                ],
+            },
+            handler: this.connectToOneOfTheAgentsHandler.bind(this),
+        };
+    }
+    async connectToOneOfTheAgentsHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: connect_to_one_of_the_agents: ${JSON.stringify(params, null, 2)}`);
+        try {
+            let { plan, subscription } = await this.subscriptionModels.loadAgentProductPlanAndSubscription(params.subscriptionPlanId);
+            if (!plan?.AgentProduct) {
+                throw new Error(`Agent product with id ${params.subscriptionPlanId} not found`);
+            }
+            const result = await this.subscriptionModels.subscribeToAgentPlan(plan.AgentProduct.id, plan.id, true);
+            if (!result.success || !result.subscription || !result.plan) {
+                return {
+                    success: false,
+                    error: result.error || "Failed to subscribe to agent plan",
+                };
+            }
+            plan = result.plan;
+            subscription = result.subscription;
+            console.log(`Loading: ${plan?.AgentProduct?.name} ${subscription?.id}`);
+            await this.updateCurrentAgentProductPlan(plan, subscription);
+            await this.assistant.handleModeSwitch("agent_direct_connection_mode", `Directly connected to agent: ${plan?.AgentProduct?.name}`, params);
+            const html = `<div class="agent-chips"><yp-agent-chip-simple
+          isSelected
+          isSubscribed="1"
+          agentProductId="${plan?.AgentProduct?.id}"
+          subscriptionId="${subscription?.id}"
+          agentName="${plan?.name}"
+          agentDescription="${plan?.AgentProduct?.description}"
+          agentImageUrl="${plan?.AgentProduct?.configuration.avatar?.imageUrl}"
+        ></yp-agent-chip-simple></div>`;
+            if (plan?.AgentProduct?.configuration.avatar?.imageUrl) {
+                this.assistant.sendAvatarUrlChange(plan?.AgentProduct?.configuration.avatar?.imageUrl, plan?.AgentProduct?.name);
+            }
+            this.assistant.triggerResponseIfNeeded("Agent selected");
+            return {
+                success: true,
+                html,
+                data: {
+                    selectedAgentInformation: JSON.stringify(this.assistant.memory.currentAgentStatus, null, 2),
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Failed to select agent";
+            console.error(`Failed to select agent: ${errorMessage}`);
+            return {
+                success: false,
+                data: errorMessage,
+                error: errorMessage,
+            };
+        }
+    }
+    get listAllAgentsAvailableForConnection() {
+        return {
+            name: "list_all_agents_available_for_connection",
+            description: "List all agent workflows available connecting to",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            handler: this.listAllAgentsAvailableForConnectionsHandler.bind(this),
+        };
+    }
+    async listAllAgentsAvailableForConnectionsHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: list_all_agents_available_for_connections: ${JSON.stringify(params, null, 2)}`);
+        try {
+            const status = await this.subscriptionModels.loadAgentSubscriptionPlans();
+            if (this.assistant.DEBUG) {
+                console.log(`list_all_agents_available_for_purchase: ${JSON.stringify(status, null, 2)}`);
+            }
+            let agentChips = "";
+            function planTypePriority(type) {
+                switch (type) {
+                    case "coming_soon":
+                        return 0;
+                    case "paid":
+                        return 1;
+                    case "free_trial":
+                        return 2;
+                    default:
+                        return 999;
+                }
+            }
+            // 2) Custom sort function
+            const sortedPlans = [...status.availablePlans].sort((a, b) => {
+                // Compare by type priority first
+                const typeComparison = planTypePriority(a.type) - planTypePriority(b.type);
+                if (typeComparison !== 0) {
+                    // If types differ, that decides the order
+                    return typeComparison;
+                }
+                // If both are the same type and it's "paid", sort by price descending
+                if (b.price && a.price && a.type === "paid" && b.type === "paid") {
+                    return b.price - a.price;
+                }
+                // Otherwise keep them in the same order if they're not "paid"
+                return 0;
+            });
+            for (const agent of sortedPlans) {
+                agentChips += `<yp-agent-chip-simple
+          subscriptionPlanId="${agent.subscriptionPlanId}"
+          type="${agent.type}"
+          agentName="${agent.name}"
+          agentDescription="${agent.description}"
+          agentImageUrl="${agent.imageUrl}"
+        ></yp-agent-chip-simple>`;
+            }
+            const html = `<div class="agent-chips">${agentChips}</div>`;
+            return {
+                success: true,
+                data: {
+                    messageToAssistant: "You have shown the user the available agents for connection with a UI widget, now the user needs to choose which one to connect to",
+                    status,
+                },
+                html,
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Failed to load agent status";
+            console.error(`Failed to load agent status: ${errorMessage}`);
+            return {
+                success: false,
+                data: errorMessage,
+                error: errorMessage,
+            };
+        }
+    }
+}

package/{agents/assistants/modes/tools/workflowConversationTools.js → dist/agents/assistants/modes/tools/subscriptionTools.js}

@@ -109,7 +109,7 @@ export class SubscriptionTools extends BaseAssistantTools {
                     return typeComparison;
                 }
                 // If both are the same type and it's "paid", sort by price descending
-                if (a.type === "paid" && b.type === "paid") {
+                if (b.price && a.price && a.type === "paid" && b.type === "paid") {
                     return b.price - a.price;
                 }
                 // Otherwise keep them in the same order if they're not "paid"
@@ -122,9 +122,6 @@ export class SubscriptionTools extends BaseAssistantTools {
           agentName="${agent.name}"
           agentDescription="${agent.description}"
           agentImageUrl="${agent.imageUrl}"
-          price="${agent.price}"
-          currency="${agent.currency}"
-          maxRunsPerCycle="${agent.maxRunsPerCycle}"
         ></yp-agent-chip-for-purchase>`;
             }
             const html = `<div class="agent-chips">${agentChips}</div>`;

package/{agents/assistants/modes/tools/workflowTools.js → dist/agents/assistants/modes/tools/workflowConverstationTools.js}

@@ -1,5 +1,5 @@
 import { BaseAssistantTools } from "./baseTools.js";
-export class WorkflowTools extends BaseAssistantTools {
+export class WorkflowConversationTools extends BaseAssistantTools {
     constructor(assistant) {
         super(assistant);
     }