@yrpri/api 9.0.98 → 9.0.100

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

@@ -18,7 +18,7 @@ export class NavigationTools extends BaseAssistantTools {
     get connectDirectlyToAgent() {
         return {
             name: "connect_directly_to_one_of_the_agents",
-            description: "Select an agent to work with, either one the user is subscribed to or one available for purchase to the user. The user does not need to be logged in to use this tool.",
+            description: "Select an agent to work with. The user needs to be logged in to use this tool.",
             type: "function",
             parameters: {
                 type: "object",
@@ -40,36 +40,30 @@ export class NavigationTools extends BaseAssistantTools {
             if (!plan?.AgentProduct) {
                 throw new Error(`Agent product with id ${params.subscriptionPlanId} not found`);
             }
-            //TODO: Does not work as the user is not logged in. Lets figure it out.
-            /*if (plan.configuration.amount == 0) {
-              const result = await this.subscriptionModels.subscribeToAgentPlan(
-                plan.AgentProduct!.id,
-                plan.id
-              );
-      
-              if (!result.success || !result.subscription || !result.plan) {
+            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",
+                    success: false,
+                    error: result.error || "Failed to subscribe to agent plan",
                 };
-              } else {
-                plan = result.plan;
-                subscription = result.subscription;
-              }
-            }*/
+            }
+            plan = result.plan;
+            subscription = result.subscription;
             console.log(`Loading: ${plan?.AgentProduct?.name} ${subscription?.id}`);
-            await this.updateCurrentAgentProductPlan(plan, subscription, {
-                sendEvent: false,
-            });
+            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
+            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></div>`;
+        ></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,
@@ -89,4 +83,84 @@ export class NavigationTools extends BaseAssistantTools {
             };
         }
     }
+    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/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/workflowConversationTools.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/workflowConverstationTools.js

@@ -0,0 +1,112 @@
+import { BaseAssistantTools } from "./baseTools.js";
+export class WorkflowConversationTools 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
+            };
+        }
+    }
+}