@yrpri/api 9.0.103 → 9.0.104

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

@@ -1,146 +0,0 @@
-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

@@ -1,332 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,166 +0,0 @@
-// 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,
-            };
-        }
-    }
-}