@yrpri/api 9.0.101 → 9.0.102

package/active-citizen/engine/allOurIdeas/explainAnswersAssistant.js

@@ -1,8 +1,18 @@
 import { OpenAI } from "openai";
 import { YpBaseChatBot } from "../../llms/baseChatBot.js";
+import ioredis from "ioredis";
+import { v4 as uuidv4 } from "uuid";
+const tlsOptions = process.env.REDIS_MEMORY_URL?.startsWith("rediss://")
+    ? { rejectUnauthorized: false }
+    : undefined;
 export class ExplainAnswersAssistant extends YpBaseChatBot {
     constructor(wsClientId, wsClients, languageName) {
-        super(wsClientId, wsClients, "undefined");
+        const redisConnection = new ioredis.default(process.env.REDIS_MEMORY_URL ||
+            process.env.REDIS_URL ||
+            "redis://localhost:6379", {
+            tls: tlsOptions,
+        });
+        super(wsClientId, wsClients, redisConnection, `${YpBaseChatBot.redisMemoryKeyPrefix}-${uuidv4()}-explain-answers-assistant`);
         this.modelName = "gpt-4o";
         this.maxTokens = 4000;
         this.temperature = 0.8;

package/active-citizen/llms/baseChatBot.js

@@ -1,6 +1,4 @@
 import { OpenAI } from "openai";
-import { v4 as uuidv4 } from "uuid";
-import ioredis from "ioredis";
 const DEBUG = false;
 const url = process.env.REDIS_MEMORY_URL ||
     process.env.REDIS_URL ||
@@ -9,68 +7,36 @@ const tlsOptions = url.startsWith("rediss://")
     ? { rejectUnauthorized: false }
     : undefined;
 export class YpBaseChatBot {
-    get redisKey() {
-        return `${YpBaseChatBot.redisMemoryKeyPrefix}-${this.memoryId}`;
-    }
     destroy() {
         this.wsClientSocket = undefined;
     }
-    static loadMemoryFromRedis(memoryId) {
-        return new Promise(async (resolve, reject) => {
-            try {
-                //@ts-ignore
-                const redis = new ioredis.default(process.env.REDIS_MEMORY_URL ||
-                    process.env.REDIS_URL ||
-                    "redis://localhost:6379", {
-                    tls: tlsOptions,
-                });
-                const memoryString = await redis.get(`${YpBaseChatBot.redisMemoryKeyPrefix}-${memoryId}`);
-                if (memoryString) {
-                    const memory = JSON.parse(memoryString);
-                    resolve(memory);
-                }
-                else {
-                    resolve(undefined);
-                }
-            }
-            catch (error) {
-                console.error("Can't load memory from redis", error);
-                resolve(undefined);
-            }
-        });
-    }
-    static getRedisKey(memoryId) {
-        return `${YpBaseChatBot.redisMemoryKeyPrefix}-${memoryId}`;
-    }
     loadMemory() {
         return new Promise(async (resolve, reject) => {
             try {
+                console.log("loadMemoryWithOwnership loadMemory: redisKey: ", this.redisKey);
                 const memoryString = await this.redis.get(this.redisKey);
                 if (memoryString) {
                     const memory = JSON.parse(memoryString);
                     resolve(memory);
                 }
                 else {
-                    resolve(this.getEmptyMemory());
+                    console.error("loadMemoryWithOwnership loadMemory: no memory found");
+                    resolve(undefined);
                 }
             }
             catch (error) {
-                console.error("Can't load memory from redis", error);
-                resolve(this.getEmptyMemory());
+                console.error("loadMemoryWithOwnership loadMemory: Can't load memory from redis", error);
+                resolve(undefined);
             }
         });
     }
-    constructor(wsClientId, wsClients, memoryId) {
+    constructor(wsClientId, wsClients, redisConnection, redisKey) {
         this.temperature = 0.7;
         this.maxTokens = 16000;
         this.llmModel = "gpt-4o";
         this.persistMemory = false;
-        //@ts-ignore
-        this.redis = new ioredis.default(process.env.REDIS_MEMORY_URL ||
-            process.env.REDIS_URL ||
-            "redis://localhost:6379", {
-            tls: tlsOptions,
-        });
+        this.redis = redisConnection;
+        this.redisKey = redisKey;
         this.wsClientId = wsClientId;
         this.wsClientSocket = wsClients.get(this.wsClientId);
         this.wsClients = wsClients;
@@ -81,34 +47,6 @@ export class YpBaseChatBot {
         this.openaiClient = new OpenAI({
             apiKey: process.env.OPENAI_API_KEY,
         });
-        this.memoryId = memoryId;
-        this.setupMemory(memoryId);
-    }
-    async setupMemory(memoryId = undefined) {
-        if (!this.memory) {
-            this.memory = await this.loadMemory();
-        }
-        else {
-            this.memoryId = uuidv4();
-            this.memory = this.getEmptyMemory();
-            if (this.wsClientSocket) {
-                this.sendMemoryId();
-            }
-            else {
-                console.error("No wsClientSocket found");
-            }
-        }
-    }
-    async getLoadedMemory() {
-        return await this.loadMemory();
-    }
-    sendMemoryId() {
-        const botMessage = {
-            sender: "assistant",
-            type: "memoryIdCreated",
-            data: this.memoryId,
-        };
-        this.wsClientSocket.send(JSON.stringify(botMessage));
     }
     async saveMemory() {
         if (this.memory) {
@@ -161,11 +99,6 @@ export class YpBaseChatBot {
         };
         this.wsClientSocket.send(JSON.stringify(botMessage));
     }
-    getEmptyMemory() {
-        return {
-            redisKey: this.redisKey,
-        };
-    }
     sendToClient(sender, message, type = "stream", uniqueToken = undefined, hiddenContextMessage = false) {
         try {
             if (process.env.WS_DEBUG) {

package/agents/assistants/agentAssistant.js

@@ -4,8 +4,8 @@ import { AgentSelectionMode } from "./modes/agentSelectionMode.js";
 import { DirectConversationMode } from "./modes/agentDirectConnection.js";
 import { SubscriptionManager } from "../managers/subscriptionManager.js";
 export class YpAgentAssistant extends YpBaseAssistantWithVoice {
-    constructor(wsClientId, wsClients, redis, voiceEnabled, domainId, memoryId) {
-        super(wsClientId, wsClients, redis, voiceEnabled, domainId, memoryId);
+    constructor(wsClientId, wsClients, redis, voiceEnabled, redisKey, domainId) {
+        super(wsClientId, wsClients, redis, voiceEnabled, redisKey, domainId);
         this.availableAgents = [];
         this.runningAgents = [];
         this.agentSelectionMode = new AgentSelectionMode(this);
@@ -44,6 +44,7 @@ export class YpAgentAssistant extends YpBaseAssistantWithVoice {
         return this.memory.currentAgentStatus?.subscriptionId != undefined;
     }
     get hasConfiguredcurrentAgentProduct() {
+        console.log(`configuration: ${this.redisKey}: ${JSON.stringify(this.memory.currentAgentStatus, null, 2)}`);
         return this.memory.currentAgentStatus?.configurationState === "configured";
     }
     async isCurrentAgentRunning() {

package/agents/assistants/baseAssistant.js

@@ -13,8 +13,8 @@ export var CommonModes;
     CommonModes["ErrorRecovery"] = "error_recovery";
 })(CommonModes || (CommonModes = {}));
 export class YpBaseAssistant extends YpBaseChatBot {
-    constructor(wsClientId, wsClients, redis, domainId, memoryId) {
-        super(wsClientId, wsClients, memoryId);
+    constructor(wsClientId, wsClients, redis, redisKey, domainId) {
+        super(wsClientId, wsClients, redis, redisKey);
         this.persistMemory = true;
         this.DEBUG = false;
         this.modes = new Map();
@@ -56,9 +56,8 @@ Never engage in off topic conversations, always politely steer the conversation
             apiKey: process.env.OPENAI_API_KEY,
         });
         this.eventEmitter = new EventEmitter();
+        this.clientSystemMessageListener = this.handleClientSystemMessage.bind(this);
         this.setupClientSystemMessageListener();
-        this.clientSystemMessageListener =
-            this.handleClientSystemMessage.bind(this);
         this.on("update-ai-model-session", this.updateAiModelSession.bind(this));
     }
     destroy() {
@@ -89,8 +88,8 @@ Never engage in off topic conversations, always politely steer the conversation
         }
     }
     setupClientSystemMessageListener() {
-        console.log("WebSockets: setupClientSystemMessageListener called for wsClientId:", this.wsClientId);
-        this.wsClientSocket.on("message", this.handleClientSystemMessage.bind(this));
+        console.log("WebSockets: setupClientSystemMessageListener called for wsClientId:", this.wsClientId, this.clientSystemMessageListener);
+        this.wsClientSocket.on("message", this.clientSystemMessageListener);
         const listenerCountAfter = this.wsClientSocket.listenerCount("message");
         console.log('Number of "message" listeners after adding:', listenerCountAfter);
     }
@@ -272,16 +271,6 @@ Never engage in off topic conversations, always politely steer the conversation
             name: toolCall.name,
         };
     }
-    getEmptyMemory() {
-        return {
-            redisKey: this.redisKey,
-            chatLog: [],
-            completeChatLog: [],
-            currentMode: "agent_selection_mode",
-            modeHistory: [],
-            modeData: undefined,
-        };
-    }
     /**
      * Handle executing tool calls with results
      */
@@ -412,25 +401,13 @@ Never engage in off topic conversations, always politely steer the conversation
             throw error;
         }
     }
-    async setupMemory(memoryId = undefined) {
-        // DO nothing override call from constructor
-    }
     async setupMemoryAsync() {
         if (!this.memory) {
-            console.log("setupMemoryAsync: loading memory");
+            console.log("loadMemoryWithOwnership: loading memory");
             this.memory = (await this.loadMemory());
         }
         if (!this.memory) {
-            console.log("setupMemoryAsync: creating new memory");
-            //this.memoryId = uuidv4();
-            this.memory = this.getEmptyMemory();
-            if (this.wsClientSocket) {
-                this.sendMemoryId();
-            }
-            else {
-                console.error("No wsClientSocket found");
-            }
-            await this.saveMemory();
+            console.error("loadMemoryWithOwnership: No memory found!!!");
         }
     }
     async loadMemoryAsync() {

package/agents/assistants/baseAssistantWithVoice.js

@@ -1,8 +1,8 @@
 import { YpBaseAssistant } from "./baseAssistant.js";
 import { YpBaseChatBotWithVoice } from "./voiceAssistant.js";
 export class YpBaseAssistantWithVoice extends YpBaseAssistant {
-    constructor(wsClientId, wsClients, redis, voiceEnabled, domainId, memoryId) {
-        super(wsClientId, wsClients, redis, domainId, memoryId);
+    constructor(wsClientId, wsClients, redis, voiceEnabled, redisKey, domainId) {
+        super(wsClientId, wsClients, redis, redisKey, domainId);
         if (!domainId) {
             throw new Error("Domain ID is required");
         }
@@ -34,7 +34,7 @@ export class YpBaseAssistantWithVoice extends YpBaseAssistant {
         }
     }
     async createVoiceBot() {
-        this.voiceBot = new YpBaseChatBotWithVoice(this.wsClientId, this.wsClients, this.memoryId, true, this);
+        this.voiceBot = new YpBaseChatBotWithVoice(this.wsClientId, this.wsClients, this.redisKey, this.redis, true, this);
         await this.voiceBot.initializeMainAssistantVoiceConnection();
         this.setupVoiceEventForwarder();
         await this.voiceBot.updateVoiceConfig({

package/agents/assistants/voiceAssistant.js

@@ -2,8 +2,8 @@ import { YpBaseChatBot } from "../../active-citizen/llms/baseChatBot.js";
 import WebSocket from "ws";
 // Extend the base class with voice capabilities
 export class YpBaseChatBotWithVoice extends YpBaseChatBot {
-    constructor(wsClientId, wsClients, memoryId, voiceEnabled = false, parentAssistant) {
-        super(wsClientId, wsClients, memoryId);
+    constructor(wsClientId, wsClients, redisKey, redisConnection, voiceEnabled = false, parentAssistant) {
+        super(wsClientId, wsClients, redisConnection, redisKey);
         this.voiceEnabled = false;
         this.VAD_TIMEOUT = 1000; // 1 second of silence for VAD
         this.sendTranscriptsToClient = false;

package/agents/controllers/assistantsController.js

@@ -188,7 +188,7 @@ export class AssistantController {
             const { requiredQuestionsAnswers } = req.body;
             const subscriptionId = parseInt(req.params.subscriptionId);
             try {
-                const memoryId = this.getMemoryUserId(req);
+                const memoryId = this.getMemoryRedisKey(req);
                 // Get subscription
                 const subscription = await YpSubscription.findOne({
                     where: {
@@ -213,80 +213,57 @@ export class AssistantController {
             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));
-                        //TODO: Check if needed, wait for 300ms to make sure redis is saved
-                        await new Promise((resolve) => setTimeout(resolve, 300));
-                        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);
-                }
+            if (!req.user) {
+                return res.status(401).json({ error: "Unauthorized" });
             }
-            else {
-                res.sendStatus(401);
+            try {
+                const memory = await this.loadMemoryWithOwnership(req, res);
+                if (!memory)
+                    return; // already 401/403 if not allowed
+                // Now memory is either newly created or already owned by this user (or still guest if you didn't upgrade)
+                memory.currentUser = req.user;
+                await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
+                res.sendStatus(200);
             }
-        };
-        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");
+            catch (error) {
+                console.error("Error updating login status:", error);
+                res.sendStatus(500);
             }
-            return `${req.params.domainId}-${userIdentifier}`;
         };
+        this.defaultStartAgentMode = "agent_selection_mode";
         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));
-                    if (req.user) {
-                        //TODO: REMOVE THIS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
-                        await YpSubscription.destroy({
-                            where: {
-                                user_id: req.user?.id,
-                            },
-                        });
-                    }
-                    else {
-                        console.warn("No user found to clear runs for");
-                    }
-                    res.sendStatus(200);
+                const memory = await this.loadMemoryWithOwnership(req, res);
+                if (!memory)
+                    return; // loadMemoryWithOwnership has already sent 401/403 if needed
+                // Now we know this request is allowed to see/modify the 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.ownerUserId === null) {
+                    memory.currentUser = undefined;
+                }
+                await req.redisClient.set(memory.redisKey, JSON.stringify(memory));
+                if (req.user) {
+                    //TODO: REMOVE THIS when we have multi workflows
+                    await YpSubscription.destroy({
+                        where: {
+                            user_id: req.user?.id,
+                        },
+                    });
                 }
                 else {
-                    console.warn(`No memory found to clear for id ${memoryId}`);
-                    res.sendStatus(200);
+                    console.warn("No user found to clear runs for");
                 }
+                res.sendStatus(200);
             }
             catch (error) {
                 console.error("Error clearing chat log:", error);
@@ -294,47 +271,11 @@ export class AssistantController {
             }
         };
         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;
-                        }
-                        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);
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
                 return;
-            }
-            if (memory) {
-                res.send(memory);
-            }
-            else {
-                console.error(`No memory found for memoryId: ${memoryId}`);
-                res.send({});
-            }
+            console.log(`Getting memory at key: ${memory.redisKey}`);
+            return res.json(memory);
         };
         // New API endpoints for workflow management
         this.getRunningWorkflowConversations = async (req, res) => {
@@ -418,10 +359,102 @@ export class AssistantController {
         const status = await this.agentQueueManager.getAgentStatus(agentId);
         return status ? status.messages[status.messages.length - 1] : null;
     }
+    getMemoryRedisKey(req) {
+        const userIdentifier = req.body.clientMemoryUuid || req.query.clientMemoryUuid;
+        return `assistant:${ /*req.params.domainId*/1}:${userIdentifier}`;
+    }
+    async loadMemoryWithOwnership(req, res) {
+        // Get the calling function name from the stack trace
+        const stackTrace = new Error().stack;
+        const callerLine = stackTrace?.split("\n")[2]; // First line is Error, second is current function, third is caller
+        const callerMatch = callerLine?.match(/at\s+(.*)\s+\(/);
+        const caller = callerMatch ? callerMatch[1] : "unknown";
+        console.debug(`loadMemoryWithOwnership called by: ${caller}`);
+        console.debug(`loadMemoryWithOwnership: ${JSON.stringify(req.body, null, 2)}`);
+        const redisKey = this.getMemoryRedisKey(req);
+        console.debug(`loadMemoryWithOwnership: redisKey: ${redisKey}`);
+        try {
+            const rawMemory = await req.redisClient.get(redisKey);
+            let memory = rawMemory
+                ? JSON.parse(rawMemory)
+                : null;
+            // If no memory, create new
+            if (!memory) {
+                console.debug(`loadMemoryWithOwnership: creating new memory`);
+                memory = {
+                    redisKey,
+                    chatLog: [],
+                    completeChatLog: [],
+                    currentMode: this.defaultStartAgentMode,
+                    modeHistory: [],
+                    modeData: undefined,
+                    ownerUserId: null,
+                };
+                if (req.user) {
+                    console.debug(`loadMemoryWithOwnership: setting ownerUserId to ${req.user.id}`);
+                    memory.ownerUserId = req.user.id;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: no user in request`);
+                }
+                await req.redisClient.set(redisKey, JSON.stringify(memory));
+                const rawAfterSet = await req.redisClient.get(redisKey);
+                console.log("loadMemoryWithOwnership: After set, raw in Redis is:", rawAfterSet);
+                console.debug(`loadMemoryWithOwnership: returning new memory`);
+                return memory;
+            }
+            else {
+                console.debug(`loadMemoryWithOwnership: memory already exists`);
+                console.debug(`loadMemoryWithOwnership: memory: ${JSON.stringify(memory, null, 2)}`);
+            }
+            // If memory is owned by someone
+            if (memory.ownerUserId !== null) {
+                console.debug(`loadMemoryWithOwnership: memory is owned by ${memory.ownerUserId}`);
+                if (!req.user) {
+                    console.debug(`loadMemoryWithOwnership: no user in request`);
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: user in request`);
+                }
+                if (memory.ownerUserId !== req.user.id) {
+                    console.debug(`loadMemoryWithOwnership: ownerUserId does not match ${memory.ownerUserId} !== ${req.user.id}`);
+                    res.status(403).json({ error: "Forbidden" });
+                    return;
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: ownerUserId matches ${memory.ownerUserId} === ${req.user.id}`);
+                }
+                // Same user => fine
+                return memory;
+            }
+            else {
+                // memory is guest
+                if (req.user) {
+                    // optionally upgrade
+                    memory.ownerUserId = req.user.id;
+                    await req.redisClient.set(redisKey, JSON.stringify(memory));
+                    console.debug(`loadMemoryWithOwnership: returning memory with ownerUserId ${memory.ownerUserId}`);
+                }
+                else {
+                    console.debug(`loadMemoryWithOwnership: returning memory with ownerUserId null`);
+                }
+                return memory;
+            }
+        }
+        catch (error) {
+            console.error("Error loading memory:", error);
+            res.status(500).json({ error: "Internal server error" });
+            return;
+        }
+    }
     async startVoiceSession(req, res) {
         try {
             const { wsClientId, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
+                return;
             console.log(`Starting chat session for client: ${wsClientId}`);
             let oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
             if (oldVoiceAssistant) {
@@ -433,7 +466,7 @@ export class AssistantController {
                 oldChatAssistant.destroy();
                 this.chatAssistantInstances.delete("mainAssistant");
             }
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, parseInt(req.params.domainId), memoryId);
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, memory.redisKey, parseInt(req.params.domainId));
             this.voiceAssistantInstances.set("voiceAssistant", assistant);
             await assistant.initialize();
             res.status(200).json({
@@ -448,9 +481,10 @@ export class AssistantController {
     }
     async sendChatMessage(req, res) {
         try {
+            const memory = await this.loadMemoryWithOwnership(req, res);
+            if (!memory)
+                return; // ends early if 401/403
             const { wsClientId, chatLog, currentMode } = req.body;
-            const memoryId = this.getMemoryUserId(req);
-            console.log(`Starting chat session for client: ${wsClientId} with currentMode: ${currentMode}`);
             const oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
             if (oldVoiceAssistant) {
                 oldVoiceAssistant.destroy();
@@ -461,7 +495,7 @@ export class AssistantController {
                 oldAssistant.destroy();
                 this.chatAssistantInstances.delete("mainAssistant");
             }
-            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, parseInt(req.params.domainId), memoryId);
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, memory.redisKey, parseInt(req.params.domainId));
             this.chatAssistantInstances.set("mainAssistant", assistant);
             assistant.conversation(chatLog);
             res.status(200).json({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.101",
+  "version": "9.0.102",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {