@yrpri/api 9.0.99 → 9.0.100

package/agents/assistants/baseAssistant.js

@@ -29,7 +29,7 @@ If interacting in a non-English language, start by using the standard accent or
 You should always call a function/tool if you can to help the user with their request.
 Never try to start workflows without using functions/tools, using some tools will unlock other function/tools that might help the user with their request.
 Functions/tools will become available to you as the user progresses through the workflow.
-Make sure that the user logged in and is subscribed to the agent before you start a workflow.
+Make sure that the user logged in before connecting him to an agent.
 Never list out the available agents using text or markdown, the user already sees the list of agents available for subscription in the UI.
 You will not be able to start the workflow for the user except using tools/functions at each step.
 Never engage in longish back and fourth conversations with the user if a workflow has not started, lead the user towards using the tools available as much as possible, politely.
@@ -37,10 +37,10 @@ Never engage in off topic conversations, always politely steer the conversation
 </coreImportantSystemInstructions>
 
 <typicalWorkflowStepsForStartingAnAgentWorkflow>
-1) The user chooses an agent to subscribe to using the direct connect to the agent the user chooses. It's only possible to subscribe to the agent after the user has connected directly to the agent.
-2) The agent offers to show the user a workflow overview, with a tool and then informs the user about the subscription process.
-3) The user logs in or creates an account, if not logged in.
-4) The user verbally confirms a subscription to the agent using a function/tool.
+1) The agent presents the user with a list of agents available for connection.
+2) The user logs in or creates an account, if the user is not logged in already.
+3) The user chooses an agent to connect to using the direct connect to the agent the user chooses.
+4) The agent offers to show the user a workflow overview, with a tool.
 5) The user fills out the configuration UI widget.
 6) The user submits from the configuration UI widget.
 7) The user starts the workflow run.
@@ -57,7 +57,8 @@ Never engage in off topic conversations, always politely steer the conversation
         });
         this.eventEmitter = new EventEmitter();
         this.setupClientSystemMessageListener();
-        this.clientSystemMessageListener = this.handleClientSystemMessage.bind(this);
+        this.clientSystemMessageListener =
+            this.handleClientSystemMessage.bind(this);
         this.on("update-ai-model-session", this.updateAiModelSession.bind(this));
     }
     destroy() {
@@ -108,6 +109,9 @@ Never engage in off topic conversations, always politely steer the conversation
             });
             return subscriptionPlan?.AgentProduct;
         }
+        else {
+            console.error("--------------------> No subscription plan found");
+        }
         return undefined;
     }
     async getCurrentSubscriptionPlan() {
@@ -206,7 +210,8 @@ Never engage in off topic conversations, always politely steer the conversation
                     throw new Error("No agent run found");
                 }
                 console.log(`agent_run_changed emitting`);
-                this.emit("update-ai-model-session", `The agent run status has been updated to ${agentRun.status} ${JSON.stringify(agentRun.workflow, null, 2)} offer the user assistance with this next step in the workflow`);
+                const currentWorkflowStep = agentRun.workflow?.steps[agentRun.workflow?.currentStepIndex];
+                this.emit("update-ai-model-session", `The agent run status has been updated to ${agentRun.status} ${JSON.stringify({ workflow: agentRun.workflow, currentWorkflowStep }, null, 2)} offer the user assistance with this next step in the workflow`);
             }
             catch (error) {
                 console.error(`Error finding agent run: ${error}`);
@@ -482,6 +487,16 @@ Never engage in off topic conversations, always politely steer the conversation
             //    this.availableTools.get("switch_mode")!,
         ];
     }
+    get isLoggedIn() {
+        return Boolean(this.memory?.currentUser);
+    }
+    renderLoginStatus() {
+        return `
+<loginStatus>
+${this.isLoggedIn ? "The user is logged in." : "The user is not logged in."}
+</loginStatus>
+`;
+    }
     /**
      * Get current mode's system prompt
      */
@@ -489,9 +504,9 @@ Never engage in off topic conversations, always politely steer the conversation
         const currentMode = this.modes.get(this.memory.currentMode);
         if (!currentMode) {
             console.error(`No current mode found: ${this.memory.currentMode}`);
-            return this.defaultSystemPrompt;
+            return `${this.defaultSystemPrompt}\n\n${this.renderLoginStatus()}`;
         }
-        return `${this.defaultSystemPrompt}\n\n<furtherAgentInstructions>\n${currentMode.systemPrompt}\n</furtherAgentInstructions>`;
+        return `${this.defaultSystemPrompt}\n\n${this.renderLoginStatus()}\n\n<furtherAgentInstructions>\n${currentMode.systemPrompt}\n</furtherAgentInstructions>`;
     }
     sendAvatarUrlChange(url, avatarName) {
         this.wsClientSocket.send(JSON.stringify({

package/agents/assistants/modes/agentDirectConnection.js

@@ -24,10 +24,8 @@ export class DirectConversationMode extends BaseAssistantMode {
                 // User logged in
                 console.log("Mode: agent_direct_connection_mode, User logged in");
                 tools.push(this.loginTools.logout);
+                tools.push(this.agentTools.showAgentWorkflowOverviewWidget);
                 if (this.assistant.isSubscribedToCurrentAgentProduct) {
-                    // User is subscribed to the current agent
-                    console.log("Mode: agent_direct_connection_mode, User is subscribed to the current agent");
-                    tools.push(this.subscriptionTools.unsubscribeFromCurrentAgentSubscription);
                     if (this.assistant.hasConfiguredcurrentAgentProduct) {
                         // User has configured the current agent
                         console.log("Mode: agent_direct_connection_mode, User has configured the current agent");
@@ -61,20 +59,7 @@ export class DirectConversationMode extends BaseAssistantMode {
                 }
                 else {
                     // User is not subscribed to the current agent
-                    console.log("Mode: agent_direct_connection_mode, User is not subscribed to the current agent");
-                    tools.push(this.subscriptionTools.subscribeToCurrentAgentPlan);
-                    tools.push(this.agentTools.showAgentWorkflowOverviewWidget);
-                }
-            }
-            else {
-                // User not logged in
-                console.log("Mode: agent_direct_connection_mode, User not logged in");
-                tools.push(this.loginTools.showLogin("Show login widget to the user if wants to subscribe to an agent or start an agent workflow. Always show the login widget if the user asks to be logged in."));
-                tools.push(this.agentTools.showAgentWorkflowOverviewWidget);
-                if (this.assistant.haveShownLoginWidget) {
-                    console.log("Mode: agent_direct_connection_mode, User has shown the login widget");
-                    tools.push(this.loginTools.clickGoogleLoginButton);
-                    tools.push(this.loginTools.clickMainLoginButton);
+                    console.error("Mode: agent_direct_connection_mode, User is not subscribed to the current agent should not happen");
                 }
             }
             return tools;

package/agents/assistants/modes/agentSelectionMode.js

@@ -1,30 +1,27 @@
 import { BaseAssistantMode } from "./baseAssistantMode.js";
-import { SubscriptionTools } from "./tools/subscriptionTools.js";
 import { NavigationTools } from "./tools/navigationTools.js";
 import { LoginAssistantTools } from "./tools/loginTools.js";
 export class AgentSelectionMode extends BaseAssistantMode {
     constructor(assistant) {
         super(assistant);
-        this.subscriptionTools = new SubscriptionTools(this.assistant);
         this.navigationTools = new NavigationTools(this.assistant);
         this.loginTools = new LoginAssistantTools(this.assistant);
     }
     async getCurrentModeSystemPrompt() {
-        let systemPrompt = `You are the main AI agent assistant. Help users select AI agents to subscribe to or connect to. Use your tools when needed.`;
+        let systemPrompt = `You are the main AI agent assistant. Help users select AI agent workflows to connect to. Use your tools when needed.`;
         systemPrompt += await this.renderCommon();
         return systemPrompt;
     }
     async getCurrentModeTools() {
         const tools = [
-            this.subscriptionTools.listAllAgentsAvailableForSubscription,
-            this.navigationTools.connectDirectlyToAgent,
+            this.navigationTools.listAllAgentsAvailableForConnection,
         ];
         if (this.assistant.isLoggedIn) {
+            tools.push(this.navigationTools.connectDirectlyToAgent);
             tools.push(this.loginTools.logout);
-            tools.push(this.subscriptionTools.listMyAgentSubscriptions);
         }
         else {
-            tools.push(this.loginTools.showLogin("Show login widget to the user if they ask to be logged in or if they ask specfically to list all of their subscribed agents. You do not need to log in to connect to an agent."));
+            tools.push(this.loginTools.showLogin("Show login widget to the user when needed. You do need to log in to connect to an agent. When you have logged in the connect directly to agent tool will be available."));
             if (this.assistant.haveShownLoginWidget) {
                 tools.push(this.loginTools.clickMainLoginButton);
                 tools.push(this.loginTools.clickGoogleLoginButton);
@@ -38,7 +35,7 @@ export class AgentSelectionMode extends BaseAssistantMode {
         const tools = await this.getCurrentModeTools();
         return {
             name: "agent_selection_mode",
-            description: "List available agents the user is subscribed to or available for purchase then connect the user to the agent selected by the user",
+            description: "List available agents the user can connect to then connect the user to the agent selected by the user",
             systemPrompt: systemPrompt,
             tools: tools,
             allowedTransitions: ["agent_direct_connection_mode"],

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

@@ -0,0 +1,326 @@
+// commonTools.ts
+import { SubscriptionModels } from "./models/subscriptions.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export class SubscriptionTools extends BaseAssistantTools {
+    constructor(assistant) {
+        super(assistant);
+        this.subscriptionModels = new SubscriptionModels(assistant);
+    }
+    get listMyAgentSubscriptions() {
+        return {
+            name: "list_my_agent_subscriptions",
+            description: "List all agent subscriptions for the current user.",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            handler: this.listMyAgentSubscriptionsHandler.bind(this),
+        };
+    }
+    async listMyAgentSubscriptionsHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: list_my_agent_subscriptions: ${JSON.stringify(params, null, 2)}`);
+        try {
+            const status = await this.subscriptionModels.loadUserAgentSubscriptions();
+            if (this.assistant.DEBUG) {
+                console.log(`list_my_agent_subscriptions: ${JSON.stringify(status, null, 2)}`);
+            }
+            let agentChips = "";
+            for (const subscription of status.availableSubscriptions) {
+                agentChips += `<div class="agent-chips"><yp-agent-chip-for-purchase
+          isSubscribed="${true}"
+          type="${subscription.Plan?.configuration.type}"
+          agentProductId="${subscription.Plan?.AgentProduct?.id}"
+          subscriptionPlanId="${subscription.Plan?.id}"
+          agentName="${subscription.Plan?.AgentProduct?.name}"
+          agentDescription="${subscription.Plan?.AgentProduct?.description}"
+          agentImageUrl="${subscription.Plan?.AgentProduct?.configuration.avatar?.imageUrl}"
+          price="${subscription.Plan?.configuration.amount}"
+          currency="${subscription.Plan?.configuration.currency}"
+          maxRunsPerCycle="${subscription.Plan?.configuration.max_runs_per_cycle}"
+        ></yp-agent-chip-for-purchase></div>`;
+            }
+            let html;
+            if (status.availableSubscriptions.length > 0) {
+                html = `<div class="agent-chips">${agentChips}</div>`;
+            }
+            else {
+                this.assistant.triggerResponseIfNeeded("The user is not subscribed to any agents, offer to show available agents for purchase");
+            }
+            return {
+                success: true,
+                data: 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,
+            };
+        }
+    }
+    get listAllAgentsAvailableForSubscription() {
+        return {
+            name: "list_all_agents_available_for_subscription",
+            description: "List all agent subscriptions available for purchase",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            handler: this.listAllAgentsAvailableForSubscriptionHandler.bind(this),
+        };
+    }
+    async listAllAgentsAvailableForSubscriptionHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: list_all_agents_available_for_purchase: ${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 (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-for-purchase
+          subscriptionPlanId="${agent.subscriptionPlanId}"
+          type="${agent.type}"
+          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>`;
+            return {
+                success: true,
+                data: {
+                    messageToAssistant: "You have shown the user the available agents for purchase with a UI widget, now the user needs to choose which one to connect to then subscribe 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,
+            };
+        }
+    }
+    get subscribeToCurrentAgentPlan() {
+        return {
+            name: "subscribe_to_current_agent_plan",
+            description: "Subscribe to the current agent plan. User must confirm subscription with the agent name before proceeding. The user needs to subscribe to the agent before it can be used so make sure to offer it to the user.",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {
+                    useHasVerballyConfirmedSubscribeWithTheAgentName: {
+                        type: "boolean",
+                    },
+                },
+                required: [
+                    "useHasVerballyConfirmedSubscribeWithTheAgentName",
+                ],
+            },
+            handler: this.subscribeToCurrentAgentPlanHandler.bind(this),
+        };
+    }
+    async subscribeToCurrentAgentPlanHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: subscribe_to_current_agent_plan: ${JSON.stringify(params, null, 2)}`);
+        try {
+            if (!params.useHasVerballyConfirmedSubscribeWithTheAgentName) {
+                return {
+                    success: false,
+                    error: "User must confirm subscription with the agent name before proceeding",
+                };
+            }
+            console.log(`-------> ${JSON.stringify(this.assistant.memory.currentAgentStatus, null, 2)}`);
+            const subscriptionPlan = await this.assistant.getCurrentSubscriptionPlan();
+            if (!subscriptionPlan) {
+                throw new Error("No subscription plan found");
+            }
+            if (!subscriptionPlan) {
+                return {
+                    success: false,
+                    data: "No current agent selected",
+                    error: "No current agent selected",
+                };
+            }
+            const result = await this.subscriptionModels.subscribeToAgentPlan(subscriptionPlan.AgentProduct.id, subscriptionPlan.id);
+            if (!result.success || !result.subscription || !result.plan) {
+                return {
+                    success: false,
+                    error: result.error || "Failed to subscribe to agent plan",
+                };
+            }
+            await this.updateCurrentAgentProductPlan(result.plan, result.subscription);
+            let html;
+            if (result.plan?.AgentProduct) {
+                html = `<div class="agent-chips"><yp-agent-chip-for-purchase
+          isSubscribed="${true}"
+          agentProductId="${result.plan.AgentProduct.id}"
+          subscriptionPlanId="${result.plan.id}"
+          agentName="${result.plan.AgentProduct.configuration.displayName}"
+          agentDescription="${result.plan.AgentProduct.description}"
+          agentImageUrl="${result.plan.AgentProduct.configuration.avatar?.imageUrl}"
+          price="${result.plan.configuration.amount}"
+          currency="${result.plan.configuration.currency}"
+          maxRunsPerCycle="${result.plan.configuration.max_runs_per_cycle}"
+        ></yp-agent-chip-for-purchase></div>`;
+            }
+            this.assistant.emit("update-ai-model-session", "Successfully subscribed to agent plan, now offer to show the configuration input tool/widget to configure the agent");
+            return {
+                success: true,
+                html,
+                data: {
+                    message: "Successfully subscribed to agent plan, now offer to show the configuration input tool/widget to configure the agent",
+                    subscription: result.subscription,
+                    subscriptionPlan: result.plan,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Failed to subscribe to agent";
+            console.error(`Failed to subscribe to agent: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    get unsubscribeFromCurrentAgentSubscription() {
+        return {
+            name: "unsubscribe_from_current_agent_subscription",
+            description: "Unsubscribe from an existing agent subscription the user is subscribed to. User must verbally confirm unsubscription with the agent name before proceeding.",
+            type: "function",
+            parameters: {
+                type: "object",
+                properties: {
+                    useHasVerballyConfirmedUnsubscribeWithTheAgentName: {
+                        type: "boolean",
+                    },
+                },
+                required: [
+                    "useHasVerballyConfirmedUnsubscribeWithTheAgentName",
+                ],
+            },
+            handler: this.unsubscribeFromCurrentAgentSubscriptionHandler.bind(this),
+        };
+    }
+    async unsubscribeFromCurrentAgentSubscriptionHandler(params) {
+        params = this.assistant.getCleanedParams(params);
+        console.log(`handler: unsubscribe_from_current_agent_subscription: ${JSON.stringify(params, null, 2)}`);
+        try {
+            if (!params.useHasVerballyConfirmedUnsubscribeWithTheAgentName) {
+                return {
+                    success: false,
+                    error: "User must verbally confirm unsubscription with the agent name before proceeding",
+                };
+            }
+            const subscriptionPlan = await this.assistant.getCurrentSubscriptionPlan();
+            if (!subscriptionPlan) {
+                return {
+                    success: false,
+                    data: "No current agent selected",
+                    error: "No current agent selected",
+                };
+            }
+            const { plan, subscription } = await this.subscriptionModels.loadAgentProductPlanAndSubscription(subscriptionPlan.id);
+            if (!subscription) {
+                return {
+                    success: false,
+                    data: "No subscription found",
+                    error: "No subscription found",
+                };
+            }
+            if (!plan) {
+                return {
+                    success: false,
+                    data: "No subscription plan found",
+                    error: "No subscription plan found",
+                };
+            }
+            const result = await this.subscriptionModels.unsubscribeFromAgentPlan(subscription.id);
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: result.error,
+                };
+            }
+            await this.updateCurrentAgentProductPlan(plan, subscription);
+            const html = `<div class="agent-chips"><yp-agent-chip
+        isUnsubscribed="${true}"
+        agentProductId="${plan.AgentProduct?.id}"
+        subscriptionId="${subscription.id}"
+        agentName="${plan.AgentProduct?.name}"
+        agentDescription="${plan.AgentProduct?.description}"
+        agentImageUrl="${plan.AgentProduct?.configuration.avatar?.imageUrl}"
+    ></yp-agent-chip></div>`;
+            this.assistant.emit("update-ai-model-session", "Successfully unsubscribed from agent subscription");
+            return {
+                success: true,
+                html,
+                data: {
+                    message: "Successfully unsubscribed from agent subscription",
+                    subscriptionId: result.subscriptionId,
+                    subscriptionPlan: plan,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : "Failed to unsubscribe from agent";
+            console.error(`Failed to unsubscribe from agent: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+}

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

@@ -20,6 +20,7 @@ export class AgentTools extends BaseAssistantTools {
     async showAgentWorkflowOverviewWidgetHandler(params) {
         try {
             const { agent, run } = await this.agentModels.getCurrentAgentAndWorkflow();
+            console.log("--------------------> agent", agent);
             const workflowJson = JSON.stringify(this.getSimpleWorkflow(agent.configuration.workflow));
             const base64Workflow = btoa(workflowJson);
             const html = `<yp-agent-workflow-widget
@@ -57,6 +58,7 @@ export class AgentTools extends BaseAssistantTools {
                 ? error.message
                 : "Failed to show workflow widget";
             console.error(errorMessage);
+            console.error("--------------------_> ", error);
             return {
                 success: false,
                 error: errorMessage,
@@ -332,7 +334,7 @@ export class AgentTools extends BaseAssistantTools {
         return {
             name: "show_configuration_widget_if_needed_or_user_asks_to_show_it",
             description: "Show the configuration widget for the current agent. The user needs to fill out the configuration before running the agent workflow to make sure to offer it to the user. \
-        The user can not provide you with the confiruation verbally or through chat, the user must provide the configuration through the configuration widget.",
+        The user can not provide you with the configuration verbally or through chat, the user must provide the configuration through the configuration widget.",
             type: "function",
             parameters: {
                 type: "object",

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

@@ -105,7 +105,7 @@ export class LoginAssistantTools extends BaseAssistantTools {
     get logout() {
         return {
             name: "logout",
-            description: "Log out from the system with confirmation if the user asks for it",
+            description: "Log out from the system with confirmation if the user asks for it. If this tools is showing it means that the user is already logged in.",
             type: "function",
             parameters: {
                 type: "object",

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

@@ -53,9 +53,9 @@ export class SubscriptionModels {
                     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,
+                    // price: plan.configuration?.amount || 0,
+                    // currency: plan.configuration?.currency || "USD",
+                    // maxRunsPerCycle: plan.configuration?.max_runs_per_cycle || 0,
                 })),
                 availableBundle: firstBundle
                     ? {
@@ -256,7 +256,7 @@ export class SubscriptionModels {
             };
         }
     }
-    async subscribeToAgentPlan(agentProductId, subscriptionPlanId) {
+    async subscribeToAgentPlan(agentProductId, subscriptionPlanId, returnCurrentSubscription = false) {
         try {
             const plan = await YpSubscriptionPlan.findOne({
                 where: {
@@ -282,6 +282,25 @@ export class SubscriptionModels {
                     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,