@yrpri/api 9.0.91 → 9.0.92

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

@@ -0,0 +1,107 @@
+import fs from "fs";
+import path from "path";
+import { v4 as uuidv4 } from "uuid";
+import { PredictionServiceClient } from "@google-cloud/aiplatform";
+import { helpers } from "@google-cloud/aiplatform";
+export class ImagenImageGenerator {
+    constructor(s3Service) {
+        this.s3Service = s3Service;
+        this.maxRetryCount = 3;
+        // Pull these from your environment or config
+        this.projectId = process.env.GOOGLE_CLOUD_PROJECT_ID || "";
+        this.location = process.env.GOOGLE_CLOUD_IMAGEN_LOCATION || "us-east1";
+        // Matches the official endpoint for Imagen v3.0:
+        this.endpoint = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/imagen-3.0-generate-002`;
+        this.s3Bucket = process.env.S3_BUCKET || "";
+        if (!this.projectId) {
+            console.warn("Warning: GOOGLE_CLOUD_PROJECT_ID is not set. Vertex AI calls may fail.");
+        }
+        if (!this.s3Bucket) {
+            console.warn("Warning: S3_BUCKET is not set. Image upload may fail.");
+        }
+    }
+    /**
+     * Generates an image from a text prompt using Vertex AI Imagen
+     * and returns a public S3 URL to the uploaded image.
+     */
+    async generateImageUrl(prompt, type = "logo") {
+        let retryCount = 0;
+        let finalUrl;
+        // Configure the API endpoint for Vertex AI
+        const clientOptions = {
+            apiEndpoint: `${this.location}-aiplatform.googleapis.com`,
+        };
+        const predictionServiceClient = new PredictionServiceClient(clientOptions);
+        while (retryCount < this.maxRetryCount && !finalUrl) {
+            try {
+                // 1) Prepare the prompt and parameters for Imagen
+                const promptText = {
+                    prompt: prompt, // The text prompt describing what you want to see
+                };
+                const instanceValue = helpers.toValue(promptText);
+                const instances = [instanceValue];
+                const parameter = {
+                    sampleCount: 1,
+                    // You can tweak these settings to your needs:
+                    // seed: 100,
+                    // addWatermark: false,
+                    aspectRatio: "16:9",
+                    safetyFilterLevel: "block_some",
+                    personGeneration: "allow_adult",
+                };
+                const parameters = helpers.toValue(parameter);
+                // 2) Build the predict request
+                const request = {
+                    endpoint: this.endpoint,
+                    instances,
+                    parameters,
+                };
+                // 3) Make the API call
+                //@ts-ignore
+                const [response] = await predictionServiceClient.predict(request);
+                const predictions = response.predictions;
+                if (!predictions || predictions.length === 0) {
+                    console.warn("No image was generated. Check the request parameters and prompt.");
+                }
+                else {
+                    // 4) Extract base64 data from the first prediction
+                    const prediction = predictions[0];
+                    const b64Data = prediction.structValue?.fields?.bytesBase64Encoded?.stringValue;
+                    if (!b64Data) {
+                        throw new Error("Prediction did not contain base64 image data.");
+                    }
+                    // 5) Decode and write to a temporary file
+                    const buff = Buffer.from(b64Data, "base64");
+                    const tmpFilePath = path.join("/tmp", `${uuidv4()}.png`);
+                    fs.writeFileSync(tmpFilePath, buff);
+                    // 6) Upload the image to S3
+                    const s3Key = `imagenAi/${uuidv4()}.png`;
+                    await this.s3Service.uploadImageToS3(this.s3Bucket, tmpFilePath, s3Key);
+                    // 7) Construct a public URL (optionally using Cloudflare)
+                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
+                        finalUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3Key}`;
+                    }
+                    else {
+                        finalUrl = `https://${this.s3Bucket}.s3.amazonaws.com/${s3Key}`;
+                    }
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with Vertex AI Imagen. Will retry...");
+                console.warn(error?.message || error);
+            }
+            // Retry logic
+            if (!finalUrl) {
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} ms before retry #${retryCount}...`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (!finalUrl) {
+            console.error(`Failed to generate Imagen after ${retryCount} retries.`);
+            return undefined;
+        }
+        return finalUrl;
+    }
+}

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

@@ -0,0 +1,110 @@
+import AWS from "aws-sdk";
+import fs from "fs";
+import axios from "axios";
+export class S3Service {
+    constructor(cloudflareApiKey, cloudflareZoneId) {
+        this.cloudflareApiKey = cloudflareApiKey;
+        this.cloudflareZoneId = cloudflareZoneId;
+    }
+    async uploadImageToS3(bucket, filePath, key) {
+        const s3 = new AWS.S3();
+        const fileContent = fs.readFileSync(filePath);
+        const params = {
+            Bucket: bucket,
+            Key: key,
+            Body: fileContent,
+            ACL: "public-read",
+            ContentType: "image/png",
+            ContentDisposition: "inline",
+        };
+        return new Promise((resolve, reject) => {
+            s3.upload(params, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                fs.unlinkSync(filePath);
+                resolve(data);
+            });
+        });
+    }
+    async deleteS3Url(imageUrl) {
+        const { bucket, key } = this.parseImageUrl(imageUrl);
+        if (!bucket || !key) {
+            throw new Error("Could not parse bucket or key from URL");
+        }
+        const s3 = new AWS.S3();
+        const params = {
+            Bucket: bucket,
+            Key: key,
+            ACL: "private",
+        };
+        console.log(`Disabling/Deleting Key from S3: ${JSON.stringify(params)}`);
+        return new Promise((resolve, reject) => {
+            s3.putObjectAcl(params, (err, data) => {
+                if (err) {
+                    console.error(`Error deleting image from S3: ${err}`);
+                    reject(err);
+                }
+                else {
+                    console.log(`Deleted image from S3: ${imageUrl}`, data);
+                    if (this.cloudflareApiKey && this.cloudflareZoneId) {
+                        console.log("Purging Cloudflare cache for image:", imageUrl);
+                        axios
+                            .post(`https://api.cloudflare.com/client/v4/zones/${this.cloudflareZoneId}/purge_cache`, { files: [imageUrl] }, {
+                            headers: {
+                                Authorization: `Bearer ${this.cloudflareApiKey}`,
+                                "Content-Type": "application/json",
+                            },
+                        })
+                            .then((response) => {
+                            console.log("Cloudflare cache purged:", response.data);
+                            resolve(data);
+                        })
+                            .catch((error) => {
+                            if (error.response) {
+                                console.error("Error purging Cloudflare cache:", error.response.data);
+                                console.error("Status code:", error.response.status);
+                                console.error("Headers:", error.response.headers);
+                            }
+                            else if (error.request) {
+                                console.error("No response received:", error.request);
+                            }
+                            else {
+                                console.error("Error setting up request:", error.message);
+                            }
+                            resolve(data);
+                        });
+                    }
+                    else {
+                        resolve(data);
+                    }
+                }
+            });
+        });
+    }
+    parseImageUrl(imageUrl) {
+        let bucket, key;
+        const cfImageProxyDomain = process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN;
+        const s3Bucket = process.env.S3_BUCKET;
+        if (cfImageProxyDomain && imageUrl.includes(cfImageProxyDomain)) {
+            const urlPath = new URL(imageUrl).pathname;
+            const [, ...pathParts] = urlPath.split("/");
+            bucket = s3Bucket;
+            key = pathParts.join("/");
+        }
+        else {
+            const match = imageUrl.match(/https:\/\/(.+?)\.s3\.amazonaws\.com\/(.+)/);
+            if (match) {
+                bucket = match[1];
+                key = match[2];
+            }
+        }
+        return { bucket, key };
+    }
+    async deleteMediaFormatsUrls(formats) {
+        for (const url of formats) {
+            await this.deleteS3Url(url);
+            console.log(`Deleted image from S3: ${url}`);
+        }
+    }
+}

package/active-citizen/models/ac_translation_cache.cjs

@@ -432,6 +432,7 @@ module.exports = (sequelize, DataTypes) => {
                         let languageInfo = {};
                         for (let i = 0; i < textsToTranslate.length; i += chunkSize) {
                             const chunk = textsToTranslate.slice(i, i + chunkSize);
+                            console.log("Calling Google Translate...");
                             const [translatedChunk, info] = await translateAPI.translate(chunk, targetLanguage);
                             translatedStrings.push(...translatedChunk);
                             if (i === 0) {
@@ -474,6 +475,7 @@ module.exports = (sequelize, DataTypes) => {
                 callback("No translation API");
                 return;
             }
+            console.log("Calling Google Translate...");
             translateAPI
                 .translate(contentToTranslate, targetLanguage)
                 .then((results) => {

package/active-citizen/workers/generativeAi.js

@@ -1,6 +1,6 @@
 import { AoiIconGenerator } from "../engine/allOurIdeas/iconGenerator.js";
 import models from "../../models/index.cjs";
-import { CollectionImageGenerator } from "../llms/collectionImageGenerator.js";
+import { CollectionImageGenerator } from "../llms/imageGeneration/collectionImageGenerator.js";
 const dbModels = models;
 const Image = dbModels.Image;
 const AcBackgroundJob = dbModels.AcBackgroundJob;

package/agents/assistants/baseAssistant.js

@@ -52,37 +52,44 @@ Never engage in off topic conversations, always politely steer the conversation
             throw new Error("Domain ID is required");
         }
         this.redis = redis;
-        this.wsClientId = wsClientId;
-        this.wsClientSocket = wsClients.get(this.wsClientId);
-        this.wsClients = wsClients;
         this.openaiClient = new OpenAI({
             apiKey: process.env.OPENAI_API_KEY,
         });
         this.eventEmitter = new EventEmitter();
         this.setupClientSystemMessageListener();
+        this.clientSystemMessageListener = this.handleClientSystemMessage.bind(this);
         this.on("update-ai-model-session", this.updateAiModelSession.bind(this));
     }
+    destroy() {
+        // remove the WebSocket “message” listener
+        this.removeClientSystemMessageListener();
+        // remove all other event listeners on the assistant’s own EventEmitter
+        this.eventEmitter.removeAllListeners();
+        // clear references
+        this.wsClientSocket = undefined;
+    }
     removeClientSystemMessageListener() {
-        this.wsClientSocket.removeAllListeners("message");
+        this.wsClientSocket.removeListener("message", this.clientSystemMessageListener);
     }
-    setupClientSystemMessageListener() {
-        console.log("setupClientSystemMessageListener called for wsClientId:", this.wsClientId);
-        this.wsClientSocket.on("message", async (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                switch (message.type) {
-                    case "client_system_message":
-                        console.log("Processing client_system_message:", message);
-                        this.processClientSystemMessage(message);
-                        break;
-                    default:
-                    //console.log('Unhandled message type:', message.type);
-                }
-            }
-            catch (error) {
-                console.error("Error processing message:", error);
+    handleClientSystemMessage(data) {
+        try {
+            const message = JSON.parse(data.toString());
+            switch (message.type) {
+                case "client_system_message":
+                    console.log("WebSockets: Processing client_system_message:", message);
+                    this.processClientSystemMessage(message);
+                    break;
+                default:
+                //console.log('Unhandled message type:', message.type);
             }
-        });
+        }
+        catch (error) {
+            console.error("Error processing message:", error);
+        }
+    }
+    setupClientSystemMessageListener() {
+        console.log("WebSockets: setupClientSystemMessageListener called for wsClientId:", this.wsClientId);
+        this.wsClientSocket.on("message", this.handleClientSystemMessage.bind(this));
         const listenerCountAfter = this.wsClientSocket.listenerCount("message");
         console.log('Number of "message" listeners after adding:', listenerCountAfter);
     }
@@ -623,10 +630,16 @@ Never engage in off topic conversations, always politely steer the conversation
     convertToOpenAIMessages(chatLog) {
         return chatLog
             .filter((message) => message.sender !== "system")
-            .map((message) => ({
-            role: message.sender,
-            content: message.message,
-        }));
+            .map((message) => {
+            if (message.message != null) {
+                return { role: message.sender, content: message.message };
+            }
+            else {
+                console.debug("Message content is null, message: " + JSON.stringify(message));
+                return null;
+            }
+        })
+            .filter((message) => message !== null);
     }
     /**
      * Handle mode switching

package/agents/assistants/baseAssistantWithVoice.js

@@ -8,6 +8,25 @@ export class YpBaseAssistantWithVoice extends YpBaseAssistant {
         }
         this.voiceEnabled = voiceEnabled;
     }
+    destroy() {
+        // 2) Remove the WebSocket listener we set up in createVoiceBot()
+        const ws = this.wsClients.get(this.wsClientId);
+        if (ws && this.mainBotWsHandler) {
+            ws.removeListener("message", this.mainBotWsHandler);
+            this.mainBotWsHandler = undefined;
+        }
+        // 3) Remove the forward event handler on the voiceBot socket
+        if (this.voiceBot?.wsClientSocket && this.forwardEventHandler) {
+            this.voiceBot.wsClientSocket.removeListener("message", this.forwardEventHandler);
+            this.forwardEventHandler = undefined;
+        }
+        if (this.voiceBot) {
+            this.voiceBot.destroy();
+            this.voiceBot = undefined;
+        }
+        // 4) Finally call super.destroy()
+        super.destroy();
+    }
     async initialize() {
         await this.initializeModes();
         if (this.voiceEnabled) {
@@ -25,7 +44,7 @@ export class YpBaseAssistantWithVoice extends YpBaseAssistant {
         });
         const ws = this.wsClients.get(this.wsClientId);
         if (ws) {
-            ws.on("message", async (data) => {
+            this.mainBotWsHandler = async (data) => {
                 try {
                     const message = JSON.parse(data.toString());
                     switch (message.type) {
@@ -42,19 +61,26 @@ export class YpBaseAssistantWithVoice extends YpBaseAssistant {
                 catch (error) {
                     console.error("Error processing message:", error);
                 }
-            });
+            };
+            ws.on("message", this.mainBotWsHandler);
         }
         else {
             console.error("No WebSocket found for client: ", this.wsClientId);
         }
     }
     destroyVoiceBot() {
-        this.voiceBot?.destroyAssistantVoiceConnection();
-        this.voiceBot = undefined;
+        if (this.voiceBot?.wsClientSocket && this.forwardEventHandler) {
+            this.voiceBot.wsClientSocket.removeListener("message", this.forwardEventHandler);
+            this.forwardEventHandler = undefined;
+        }
+        if (this.voiceBot) {
+            this.voiceBot.destroy();
+            this.voiceBot = undefined;
+        }
     }
     setupVoiceEventForwarder() {
         // Forward all voice bot events to client
-        this.voiceBot?.wsClientSocket?.on("message", (data) => {
+        this.forwardEventHandler = (data) => {
             try {
                 const event = JSON.parse(data.toString());
                 // Forward all voice-related events to client
@@ -78,7 +104,8 @@ export class YpBaseAssistantWithVoice extends YpBaseAssistant {
             catch (error) {
                 console.error("Error forwarding voice event:", error);
             }
-        });
+        };
+        this.voiceBot?.wsClientSocket?.on("message", this.forwardEventHandler);
     }
     async setVoiceMode(enabled) {
         this.voiceEnabled = enabled;

package/agents/assistants/voiceAssistant.js

@@ -19,7 +19,8 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
         };
         // Default voice configuration
         this.voiceConfig = {
-            model: process.env.OPENAI_VOICE_MODEL_NAME || "gpt-4o-realtime-preview-2024-12-17",
+            model: process.env.OPENAI_VOICE_MODEL_NAME ||
+                "gpt-4o-realtime-preview-2024-12-17",
             voice: "echo",
             modalities: ["text", "audio"],
         };
@@ -155,7 +156,8 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
         }
     }
     setupVoiceMessageHandlers(ws, disableWhenAgentIsSpeaking) {
-        ws.on("message", async (data) => {
+        // Instead of an inline callback, keep a reference
+        const handler = async (data) => {
             try {
                 const event = JSON.parse(data.toString());
                 if (disableWhenAgentIsSpeaking && this.directAgentVoiceConnection) {
@@ -221,7 +223,33 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
             catch (error) {
                 console.error("Error handling voice message:", error);
             }
-        });
+        };
+        // Attach it
+        ws.on("message", handler);
+        // Store the reference so we can remove it in destroy()
+        if (disableWhenAgentIsSpeaking) {
+            this.voiceMainMessageHandler = handler;
+        }
+        else {
+            this.voiceDirectMessageHandler = handler;
+        }
+    }
+    destroy() {
+        // 1) Remove voice message handlers from assistantVoiceConnection
+        if (this.assistantVoiceConnection?.ws && this.voiceMainMessageHandler) {
+            this.assistantVoiceConnection.ws.removeListener("message", this.voiceMainMessageHandler);
+            this.voiceMainMessageHandler = undefined;
+        }
+        // 2) Remove voice message handlers from directAgentVoiceConnection
+        if (this.directAgentVoiceConnection?.ws && this.voiceDirectMessageHandler) {
+            this.directAgentVoiceConnection.ws.removeListener("message", this.voiceDirectMessageHandler);
+            this.voiceDirectMessageHandler = undefined;
+        }
+        // 3) Close any open connections
+        this.destroyAssistantVoiceConnection();
+        this.destroyDirectAgentVoiceConnection();
+        // 4) Call super destroy so it can remove *its* WebSocket listeners, etc.
+        super.destroy();
     }
     async handleResponseDone(event) {
         if (event.item?.content && event.item.content.length > 0) {

package/agents/controllers/agentSubscriptionController.js

@@ -11,23 +11,28 @@ export class AgentSubscriptionController {
         this.router = express.Router();
         this.getAgentConfigurationAnswers = async (req, res) => {
             try {
-                const subscriptionId = parseInt(req.params.subscriptionId);
-                // Make sure the user can only fetch their own subscription
-                const subscription = await YpSubscription.findOne({
-                    where: {
-                        id: subscriptionId,
-                        user_id: req.user.id
-                    },
-                });
-                if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                if (req.user) {
+                    const subscriptionId = parseInt(req.params.subscriptionId);
+                    // Make sure the user can only fetch their own subscription
+                    const subscription = await YpSubscription.findOne({
+                        where: {
+                            id: subscriptionId,
+                            user_id: req.user?.id
+                        },
+                    });
+                    if (!subscription) {
+                        return res.status(404).json({ error: "Subscription not found" });
+                    }
+                    // Extract the requiredQuestionsAnswered from subscription.configuration
+                    const answers = subscription.configuration?.requiredQuestionsAnswered || [];
+                    return res.status(200).json({
+                        success: true,
+                        data: answers,
+                    });
+                }
+                else {
+                    return res.status(401).json({ error: "Unauthorized" });
                 }
-                // Extract the requiredQuestionsAnswered from subscription.configuration
-                const answers = subscription.configuration?.requiredQuestionsAnswered || [];
-                return res.status(200).json({
-                    success: true,
-                    data: answers,
-                });
             }
             catch (error) {
                 console.error("Error retrieving subscription agent configuration:", error);

package/agents/controllers/assistantsController.js

@@ -113,6 +113,9 @@ export class AssistantController {
         };
         this.getAgentConfigurationAnswers = async (req, res) => {
             try {
+                if (!req.user) {
+                    return res.status(401).json({ error: "Unauthorized" });
+                }
                 const subscriptionId = parseInt(req.params.subscriptionId);
                 // Make sure the user can only fetch their own subscription
                 const subscription = await YpSubscription.findOne({
@@ -139,6 +142,9 @@ export class AssistantController {
         this.getUpdatedWorkflow = async (req, res) => {
             const { runId } = req.params;
             const userId = req.user?.id;
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
             try {
                 const agentRun = await YpAgentProductRun.findOne({
                     where: {
@@ -359,12 +365,18 @@ export class AssistantController {
             const { wsClientId, currentMode } = req.body;
             const memoryId = this.getMemoryUserId(req);
             console.log(`Starting chat session for client: ${wsClientId}`);
-            let assistant = this.voiceAssistantInstances.get(wsClientId);
-            if (assistant) {
-                assistant.removeClientSystemMessageListener();
+            let oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
+            if (oldVoiceAssistant) {
+                oldVoiceAssistant.destroy();
+                this.voiceAssistantInstances.delete("voiceAssistant");
+            }
+            let oldChatAssistant = this.chatAssistantInstances.get("mainAssistant");
+            if (oldChatAssistant) {
+                oldChatAssistant.destroy();
+                this.chatAssistantInstances.delete("mainAssistant");
             }
-            assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, parseInt(req.params.domainId), memoryId);
-            this.voiceAssistantInstances.set(wsClientId, assistant);
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, true, parseInt(req.params.domainId), memoryId);
+            this.voiceAssistantInstances.set("voiceAssistant", assistant);
             await assistant.initialize();
             res.status(200).json({
                 message: "Voice session initialized",
@@ -372,7 +384,7 @@ export class AssistantController {
             });
         }
         catch (error) {
-            console.error("Error starting chat session:", error);
+            console.error("Error starting voice session:", error);
             res.status(500).json({ error: "Internal server error" });
         }
     }
@@ -381,11 +393,18 @@ export class AssistantController {
             const { wsClientId, chatLog, currentMode } = req.body;
             const memoryId = this.getMemoryUserId(req);
             console.log(`Starting chat session for client: ${wsClientId} with currentMode: ${currentMode}`);
-            let assistant = this.chatAssistantInstances.get(wsClientId);
-            if (!assistant) {
-                assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, parseInt(req.params.domainId), memoryId);
-                this.chatAssistantInstances.set(wsClientId, assistant);
+            const oldVoiceAssistant = this.voiceAssistantInstances.get("voiceAssistant");
+            if (oldVoiceAssistant) {
+                oldVoiceAssistant.destroy();
+                this.voiceAssistantInstances.delete("voiceAssistant");
+            }
+            const oldAssistant = this.chatAssistantInstances.get("mainAssistant");
+            if (oldAssistant) {
+                oldAssistant.destroy();
+                this.chatAssistantInstances.delete("mainAssistant");
             }
+            const assistant = new YpAgentAssistant(wsClientId, this.wsClients, req.redisClient, false, parseInt(req.params.domainId), memoryId);
+            this.chatAssistantInstances.set("mainAssistant", assistant);
             assistant.conversation(chatLog);
             res.status(200).json({
                 message: "Chat session initialized",

package/agents/managers/newAiModelSetup.js

@@ -39,6 +39,9 @@ export class NewAiModelSetup {
                     await psModels[modelName].associate(psSequelize.models);
                 }
             }
+            if (process.env.FORCE_DB_SYNC || process.env.NODE_ENV === "development") {
+                await psSequelize.sync();
+            }
             console.log("All models initialized successfully.");
         }
         catch (error) {

package/agents/managers/subscriptionManager.js

@@ -321,7 +321,7 @@ export class SubscriptionManager {
                 return { freeSubscription: true };
             }
             const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
-                apiVersion: "2024-09-30.acacia",
+                apiVersion: "2025-01-27.acacia",
             });
             // Create a PaymentIntent with Stripe
             const paymentIntent = await stripe.paymentIntents.create({
@@ -359,7 +359,7 @@ export class SubscriptionManager {
     async handleSuccessfulPayment(paymentIntentId) {
         try {
             const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
-                apiVersion: "2024-09-30.acacia",
+                apiVersion: "2025-01-27.acacia",
             });
             const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId);
             if (paymentIntent.status !== "succeeded") {