@yrpri/api 9.0.102 → 9.0.104

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

@@ -1,326 +0,0 @@
-// 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/workflowTools.js

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

package/agents/controllers/assistantController.js

@@ -1,243 +0,0 @@
-import express from "express";
-import auth from "../../authorization.cjs";
-import { YpAgentAssistant } from "../assistants/agentAssistant.js";
-import { YpAgentProductBundle } from "../models/agentProductBundle.js";
-import { YpAgentProductRun } from "../models/agentProductRun.js";
-import { YpAgentProduct } from "../models/agentProduct.js";
-import { YpAgentProductBoosterPurchase } from "../models/agentProductBoosterPurchase.js";
-import { YpSubscription } from "../models/subscription.js";
-import { YpSubscriptionPlan } from "../models/subscriptionPlan.js";
-import { YpSubscriptionUser } from "../models/subscriptionUser.js";
-import { YpDiscount } from "../models/discount.js";
-import { sequelize } from "@policysynth/agents/dbModels/index.js";
-import { NotificationAgentQueueManager } from "../managers/notificationAgentQueueManager.js";
-const models = {
-    YpAgentProduct,
-    YpAgentProductBundle,
-    YpAgentProductBoosterPurchase,
-    YpAgentProductRun,
-    YpSubscription,
-    YpSubscriptionPlan,
-    YpSubscriptionUser,
-    YpDiscount,
-};
-export class AssistantController {
-    constructor(wsClients) {
-        this.path = "/api/assistants";
-        this.router = express.Router();
-        this.initializeModels = async () => {
-            try {
-                console.log(`All Models Loaded Init`);
-                // Call associate method to set up associations
-                for (const modelName of Object.keys(models)) {
-                    if (models[modelName].associate) {
-                        await models[modelName].associate(sequelize.models);
-                        //await models[modelName].associate(models);
-                    }
-                }
-                console.log("All agentmodels initialized successfully.");
-            }
-            catch (error) {
-                console.error("Error initializing models:", error);
-                process.exit(1);
-            }
-        };
-        this.startWorkflowAgent = async (req, res) => {
-            const { groupId, agentId, wsClientId } = req.params;
-            try {
-                const notificationManager = new NotificationAgentQueueManager(this.wsClients);
-                await notificationManager.startAgentProcessingWithWsClient(parseInt(agentId), parseInt(groupId), wsClientId);
-                res.sendStatus(200);
-            }
-            catch (error) {
-                console.error("Error starting agent:", error);
-                res.sendStatus(500);
-            }
-        };
-        this.submitAgentConfiguration = async (req, res) => {
-            console.log(`submitAgentConfiguration: ${JSON.stringify(req.body, null, 2)}`);
-            const { agentProductId, subscriptionId, requiredQuestionsAnswers } = req.body;
-            try {
-                const memoryId = this.getMemoryUserId(req);
-                // Get subscription
-                const subscription = await YpSubscription.findOne({
-                    where: {
-                        id: subscriptionId,
-                    },
-                });
-                if (!subscription) {
-                    res.sendStatus(404);
-                    return;
-                }
-                subscription.configuration.requiredQuestionsAnswered =
-                    requiredQuestionsAnswers;
-                subscription.changed("configuration", true);
-                await subscription.save();
-            }
-            catch (error) {
-                console.error("Error saving subscription:", error);
-                res.sendStatus(500);
-                return;
-            }
-            res.sendStatus(200);
-        };
-        this.updateAssistantMemoryLoginStatus = async (req, res) => {
-            if (req.user && req.params.domainId) {
-                try {
-                    let memoryId = this.getMemoryUserId(req);
-                    let redisKey = YpAgentAssistant.getRedisKey(memoryId);
-                    console.log(`Starting to update login status for memoryId: ${memoryId} with user: ${req.user?.name}`);
-                    let memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                    if (memory) {
-                        memory.currentUser = req.user;
-                        await req.redisClient.set(redisKey, JSON.stringify(memory));
-                        console.log(`Updated login status for memoryId: ${memoryId} with user: ${req.user?.name}`);
-                    }
-                    else {
-                        console.error(`No memory found to update login status for id ${memoryId}`);
-                    }
-                    res.sendStatus(200);
-                }
-                catch (error) {
-                    console.error("Error updating login status:", error);
-                    res.sendStatus(500);
-                }
-            }
-            else {
-                res.sendStatus(401);
-            }
-        };
-        this.defaultStartAgentMode = "agent_selection_mode";
-        this.getMemoryUserId = (req) => {
-            const userIdentifier = req.body.clientMemoryUuid || req.query.clientMemoryUuid;
-            if (!userIdentifier) {
-                throw new Error("No user identifier found");
-            }
-            return `${req.params.domainId}-${userIdentifier}`;
-        };
-        this.clearChatLog = async (req, res) => {
-            try {
-                const memoryId = this.getMemoryUserId(req);
-                console.log(`Clearing chat log for memoryId: ${memoryId}`);
-                const redisKey = YpAgentAssistant.getRedisKey(memoryId);
-                const memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                if (memory) {
-                    if (!memory.allChatLogs) {
-                        memory.allChatLogs = [];
-                    }
-                    if (memory.chatLog) {
-                        memory.allChatLogs = [...memory.allChatLogs, ...memory.chatLog];
-                    }
-                    memory.chatLog = [];
-                    memory.currentMode = this.defaultStartAgentMode;
-                    memory.haveShownConfigurationWidget = false;
-                    memory.haveShownLoginWidget = false;
-                    memory.currentAgentStatus = undefined;
-                    if (!req.user) {
-                        memory.currentUser = undefined;
-                    }
-                    await req.redisClient.set(redisKey, JSON.stringify(memory));
-                    res.sendStatus(200);
-                }
-                else {
-                    console.warn(`No memory found to clear for id ${memoryId}`);
-                    res.sendStatus(200);
-                }
-            }
-            catch (error) {
-                console.error("Error clearing chat log:", error);
-                res.sendStatus(500);
-            }
-        };
-        this.getMemory = async (req, res) => {
-            let memory;
-            let memoryId;
-            try {
-                memoryId = this.getMemoryUserId(req);
-                console.log(`Getting memory for memoryId: ${memoryId}`);
-                if (memoryId) {
-                    memory = (await YpAgentAssistant.loadMemoryFromRedis(memoryId));
-                    if (!memory) {
-                        console.log(`memory not found for id ${memoryId}`);
-                        memory = {
-                            redisKey: YpAgentAssistant.getRedisKey(memoryId),
-                            chatLog: [],
-                            currentMode: this.defaultStartAgentMode,
-                            modeHistory: [],
-                            modeData: undefined,
-                        };
-                        await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
-                    }
-                    else {
-                        if (req.user && !memory.currentUser) {
-                            memory.currentUser = req.user;
-                            await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
-                        }
-                        else if (!req.user && memory.currentUser) {
-                            memory.currentUser = undefined;
-                            await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                console.log(error);
-                res.sendStatus(500);
-                return;
-            }
-            if (memory) {
-                res.send(memory);
-            }
-            else {
-                console.error(`No memory found for memoryId: ${memoryId}`);
-                res.send({});
-            }
-        };
-        this.wsClients = wsClients;
-        this.initializeRoutes();
-        this.initializeModels();
-    }
-    initializeRoutes() {
-        this.router.put("/:domainId/chat", auth.can("view domain"), this.sendChatMessage.bind(this));
-        this.router.post("/:domainId/voice", auth.can("view domain"), this.startVoiceSession.bind(this));
-        this.router.get("/:domainId/memory", auth.can("view domain"), this.getMemory.bind(this));
-        this.router.delete("/:domainId/chatlog", auth.can("view domain"), this.clearChatLog.bind(this));
-        this.router.put("/:domainId/updateAssistantMemoryLoginStatus", this.updateAssistantMemoryLoginStatus.bind(this));
-        this.router.put("/:domainId/submitAgentConfiguration", this.submitAgentConfiguration.bind(this));
-        this.router.put("/:groupId/:agentId/startWorkflowAgent", this.startWorkflowAgent.bind(this));
-    }
-    async startVoiceSession(req, res) {
-        try {
-            const { wsClientId, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
-            console.log(`Starting chat session for client: ${wsClientId}`);
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, parseInt(req.params.domainId), memoryId);
-            await assistant.initialize();
-            res.status(200).json({
-                message: "Voice session initialized",
-                wsClientId,
-            });
-        }
-        catch (error) {
-            console.error("Error starting chat session:", error);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    }
-    async sendChatMessage(req, res) {
-        try {
-            const { wsClientId, chatLog, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
-            console.log(`Starting chat session for client: ${wsClientId} with currentMode: ${currentMode}`);
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, parseInt(req.params.domainId), memoryId);
-            assistant.conversation(chatLog);
-            res.status(200).json({
-                message: "Chat session initialized",
-                wsClientId,
-            });
-        }
-        catch (error) {
-            console.error("Error starting chat session:", error);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    }
-}