@yrpri/api 9.0.101 → 9.0.103

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/active-citizen/llms/imageGeneration/chatGptImageGenerator.js

@@ -0,0 +1,56 @@
+// chatGptImageGenerator.ts
+import { OpenAI } from "openai";
+export class ChatGptImageGenerator {
+    constructor(openAiKey) {
+        this.maxRetryCount = 3;
+        // the SDK will fall back to process.env.OPENAI_API_KEY if nothing is passed
+        this.openAiKey = openAiKey;
+    }
+    /**
+     * Generates an image URL from a prompt using OpenAI’s gpt-image-1 model.
+     * The returned link remains live for ~60 minutes – be sure to download
+     * or cache it right away in the calling service.
+     */
+    async generateImageUrl(prompt, type = "logo") {
+        const client = new OpenAI({ apiKey: this.openAiKey });
+        // Pick a sensible canvas size from the image type
+        let size = "1536x1024";
+        if (type === "icon")
+            size = "1024x1024";
+        else if (type === "other")
+            size = "1536x1024";
+        const finalPrompt = `
+    ${prompt}
+
+    Instruction: Create a high quality logo like image for the users project and follow their style instructions. \
+    Do not add text to the images unless asked in the style instructions.
+    `;
+        let retryCount = 0;
+        while (retryCount < this.maxRetryCount) {
+            try {
+                const res = await client.images.generate({
+                    model: "gpt-image-1",
+                    prompt: finalPrompt,
+                    quality: "medium",
+                    n: 1,
+                    size
+                });
+                const url = res?.data?.[0]?.url;
+                if (url)
+                    return url;
+                throw new Error("No URL returned");
+            }
+            catch (err) {
+                retryCount += 1;
+                if (retryCount >= this.maxRetryCount) {
+                    console.error(`ChatGptImageGenerator failed after ${retryCount} attempts`, err);
+                    return undefined;
+                }
+                // Exponential back-off – starts at 5 s and grows +5 s each retry
+                await new Promise((r) => setTimeout(r, 5000 + retryCount * 5000));
+            }
+        }
+        return undefined;
+    }
+}
+export default ChatGptImageGenerator;

package/active-citizen/llms/imageGeneration/collectionImageGenerator.js

@@ -9,6 +9,7 @@ import { S3Service } from "./s3Service.js";
 // Suppose these come from your codebase
 import models from "../../../models/index.cjs";
 import { ImagenImageGenerator } from "./imagenImageGenerator.js";
+import { ChatGptImageGenerator } from "./chatGptImageGenerator.js";
 // For reference, in your code:
 const dbModels = models;
 const Image = dbModels.Image;
@@ -26,6 +27,7 @@ export class CollectionImageGenerator {
             this.fluxImageGenerator = new FluxImageGenerator(process.env.REPLICATE_API_TOKEN, process.env.FLUX_PRO_MODEL_NAME);
         }
         this.dalleImageGenerator = new DalleImageGenerator(process.env.AZURE_OPENAI_API_BASE, process.env.AZURE_OPENAI_API_KEY, process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME, process.env.OPENAI_API_KEY);
+        this.chatGptImageGenerator = new ChatGptImageGenerator(process.env.OPENAI_API_KEY);
         if (useImagen && process.env.GOOGLE_CLOUD_PROJECT_ID) {
             this.imagenImageGenerator = new ImagenImageGenerator(this.s3Service);
         }
@@ -50,6 +52,10 @@ export class CollectionImageGenerator {
                     imageGenerator = this.fluxImageGenerator;
                     console.info("Using FluxImageGenerator");
                 }
+                else if (process.env.USE_CHATGPT_IMAGE_GENERATOR) {
+                    imageGenerator = this.chatGptImageGenerator;
+                    console.info("Using ChatGptImageGenerator");
+                }
                 else {
                     imageGenerator = this.dalleImageGenerator;
                     console.info("Using DalleImageGenerator");

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/agentProductController.js

@@ -22,7 +22,8 @@ export class AgentProductController {
                 const agentProductId = parseInt(req.params.agentProductId);
                 const agentProduct = await this.agentProductManager.getAgentProduct(agentProductId);
                 if (!agentProduct) {
-                    return res.status(404).json({ error: 'Agent product not found' });
+                    res.status(404).json({ error: 'Agent product not found' });
+                    return;
                 }
                 res.json(agentProduct);
             }

package/agents/controllers/agentSubscriptionController.js

@@ -21,22 +21,25 @@ export class AgentSubscriptionController {
                         },
                     });
                     if (!subscription) {
-                        return res.status(404).json({ error: "Subscription not found" });
+                        res.status(404).json({ error: "Subscription not found" });
+                        return;
                     }
                     // Extract the requiredQuestionsAnswered from subscription.configuration
                     const answers = subscription.configuration?.requiredQuestionsAnswered || [];
-                    return res.status(200).json({
+                    res.status(200).json({
                         success: true,
                         data: answers,
                     });
+                    return;
                 }
                 else {
-                    return res.status(401).json({ error: "Unauthorized" });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
                 }
             }
             catch (error) {
                 console.error("Error retrieving subscription agent configuration:", error);
-                return res.status(500).json({ error: error.message });
+                res.status(500).json({ error: error.message });
             }
         };
         this.updateAgentConfiguration = async (req, res) => {
@@ -44,13 +47,15 @@ export class AgentSubscriptionController {
                 const subscriptionId = parseInt(req.params.subscriptionId);
                 const requiredQuestionsAnswered = req.body.requiredQuestionsAnswered;
                 if (!requiredQuestionsAnswered) {
-                    return res.status(400).json({ error: "requiredQuestionsAnswered is required" });
+                    res.status(400).json({ error: "requiredQuestionsAnswered is required" });
+                    return;
                 }
                 const subscription = await YpSubscription.findOne({
                     where: { id: subscriptionId, user_id: req.user.id }
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 subscription.configuration.requiredQuestionsAnswered = JSON.parse(requiredQuestionsAnswered);
                 subscription.changed('configuration', true);
@@ -78,13 +83,13 @@ export class AgentSubscriptionController {
                 const userId = req.user.id;
                 // If not a free trial request, redirect to payment intent endpoint
                 if (!isFreeTrialRequest) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "For paid subscriptions, please use /stripe-create-payment-intent instead",
                     });
                 }
                 // Handle free trial subscription
                 if (!planIds) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "agentProductIds and planIds are required",
                     });
                 }
@@ -146,7 +151,8 @@ export class AgentSubscriptionController {
                     where: { id: subscriptionId, user_id: userId },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 subscription.status = "cancelled";
                 await subscription.save();
@@ -166,7 +172,8 @@ export class AgentSubscriptionController {
                     where: { id: subscriptionId, user_id: userId },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 // Apply updates (validate as necessary)
                 Object.assign(subscription, updates);
@@ -183,15 +190,17 @@ export class AgentSubscriptionController {
                 const userId = req.user.id;
                 const { planIds, paymentMethodId } = req.body;
                 if (!planIds || !paymentMethodId) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "planIds, and paymentMethodId are required",
                     });
+                    return;
                 }
                 const result = await this.subscriptionManager.createSubscriptions(userId, planIds, paymentMethodId);
                 res.status(200).json({
                     clientSecret: result.clientSecret,
                     subscriptionId: result.subscriptionId,
                 });
+                return;
             }
             catch (error) {
                 console.error("Error creating payment intent:", error);