@peopl-health/nexus 1.7.12 → 2.0.1

package/lib/assistants/BaseAssistant.js

@@ -1,6 +1,7 @@
 const llmConfig = require('../config/llmConfig');
 const { Thread } = require('../models/threadModel');
 const { getLastNMessages } = require('../helpers/assistantHelper');
+const { createProvider } = require('../providers/createProvider');
 
 /**
  * Flexible base assistant implementation that integrates with OpenAI Threads
@@ -8,7 +9,6 @@ const { getLastNMessages } = require('../helpers/assistantHelper');
  */
 class BaseAssistant {
   constructor(options = {}) {
-    console.log('options', options);
     this.assistantId = options.assistantId || null;
     this.thread = options.thread || null;
     this.status = options.status || 'idle';
@@ -25,8 +25,10 @@ class BaseAssistant {
 
     if (!this.provider && this.client) {
       try {
-        const { OpenAIProvider } = require('../providers/OpenAIProvider');
-        const provider = new OpenAIProvider({ client: this.client });
+        const provider = createProvider({
+          client: this.client,
+          variant: process.env.VARIANT || 'assistants'
+        });
         this.provider = provider;
         if (typeof llmConfig.setOpenAIProvider === 'function') {
           llmConfig.setOpenAIProvider(provider);
@@ -54,7 +56,24 @@ class BaseAssistant {
 
   _ensureClient() {
     if (!this.client) {
-      throw new Error('LLM client not configured. Ensure openaiClient is initialized.');
+      this.client = this.provider?.getClient?.() || null;
+    }
+
+    if (!this.client) {
+      throw new Error('LLM client not configured. Ensure client is initialized.');
+    }
+
+    if (!this.provider) {
+      try {
+        const variant = process.env.VARIANT || 'assistants';
+        const provider = createProvider({ client: this.client, variant });
+        this.provider = provider;
+        if (typeof llmConfig.setOpenAIProvider === 'function') {
+          llmConfig.setOpenAIProvider(provider);
+        }
+      } catch (error) {
+        console.warn('[BaseAssistant] Failed to bootstrap provider:', error?.message || error);
+      }
     }
   }
 
@@ -147,35 +166,41 @@ class BaseAssistant {
       throw new Error('Assistant thread not initialized. Call create() before sendMessage().');
     }
 
-    await this.client.beta.threads.messages.create(
-      this.thread.thread_id,
-      { role: 'user', content: message }
-    );
+    const provider = this.provider || null;
+    if (!provider || typeof provider.addMessage !== 'function') {
+      throw new Error('Provider not configured. Ensure configureLLMProvider has been called.');
+    }
 
-    const runConfig = {
-      assistant_id: this.assistantId,
-      ...options
-    };
+    const assistantId = this.assistantId;
+    const threadId = this.thread.thread_id;
+    await provider.addMessage({ threadId, role: 'user', content: message });
+
+    const runConfig = { threadId, assistantId, ...options };
 
     const toolSchemas = this.getToolSchemas();
     if (toolSchemas.length > 0) {
       runConfig.tools = toolSchemas;
     }
 
-    const run = await this.client.beta.threads.runs.create(
-      this.thread.thread_id,
-      runConfig
-    );
+    const run = await provider.runConversation(runConfig);
 
-    return await this.waitForCompletion(this.thread.thread_id, run.id);
+    return await this.waitForCompletion(threadId, run.id, options);
   }
 
   async waitForCompletion(threadId, runId, { interval = 2000, maxAttempts = 30 } = {}) {
     this._ensureClient();
-    let attempts = 0;
+    const provider = this.provider || null;
+    if (!provider || typeof provider.getRun !== 'function') {
+      throw new Error('Provider not configured. Cannot poll run status.');
+    }
 
+    let attempts = 0;
     while (attempts < maxAttempts) {
-      const run = await this.client.beta.threads.runs.retrieve(threadId, runId);
+      const run = await provider.getRun({ threadId, runId });
+
+      if (!run) {
+        throw new Error('Unable to retrieve run status.');
+      }
 
       if (run.status === 'completed') {
         return run;
@@ -183,7 +208,7 @@ class BaseAssistant {
 
       if (run.status === 'requires_action') {
         await this.handleRequiresAction(run);
-      } else if (['failed', 'cancelled', 'expired', 'incomplete'].includes(run.status)) {
+      } else if (['failed', 'cancelled', 'expired', 'incomplete', 'errored'].includes(run.status)) {
         throw new Error(`Assistant run ended with status '${run.status}'`);
       }
 
@@ -199,13 +224,26 @@ class BaseAssistant {
     const threadRef = threadDoc || this.thread;
     if (!threadRef) return [];
 
-    const response = await this.client.beta.threads.messages.list(threadRef.thread_id, { order: 'asc' });
-    return response.data.map((msg) => {
-      const textContents = msg.content
-        .filter((part) => part.type === 'text')
-        .map((part) => part.text.value);
+    const provider = this.provider || null;
+    if (!provider || typeof provider.listMessages !== 'function') {
+      throw new Error('OpenAI provider not configured. Cannot list messages.');
+    }
+
+    const response = await provider.listMessages({ threadId: threadRef.thread_id, order: 'asc' });
+    const messages = Array.isArray(response?.data) ? response.data : Array.isArray(response?.items) ? response.items : [];
+
+    return messages.map((msg) => {
+      const parts = Array.isArray(msg.content) ? msg.content : [];
+      const textContents = parts
+        .map((part) => {
+          if (part.type === 'text' && part.text?.value) return part.text.value;
+          if ((part.type === 'input_text' || part.type === 'output_text') && part.text) return part.text;
+          return null;
+        })
+        .filter(Boolean);
+
       const content = textContents.length <= 1 ? textContents[0] || '' : textContents;
-      return { role: msg.role, content };
+      return { role: msg.role || 'user', content };
     });
   }
 
@@ -218,19 +256,25 @@ class BaseAssistant {
       this.lastMessages = await getLastNMessages(whatsappId, 20);
     }
 
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    if (!provider || typeof provider.createConversation !== 'function') {
+      throw new Error('Provider not configured. Cannot create conversation.');
+    }
+
     const initialMessages = await this.buildInitialMessages({ code, context });
-    const threadPayload = {};
+    const conversation = await provider.createConversation({
+      messages: initialMessages,
+    });
 
-    if (initialMessages.length > 0) {
-      threadPayload.messages = initialMessages.map((msg) => ({
-        role: msg.role || 'assistant',
-        content: msg.content
-      }));
-    }
+    this.thread = {
+      ...conversation,
+      thread_id: conversation?.id,
+      assistant_id: this.assistantId.startsWith('assistant') ? this.assistantId : null,
+      prompt_id: this.assistantId.startsWith('pmpt') ? this.assistantId : null,
+      code,
+    };
 
-    const thread = await this.client.beta.threads.create(threadPayload);
-    this.thread = thread;
-    return thread;
+    return this.thread;
   }
 
   async buildInitialMessages({ code }) {
@@ -264,16 +308,17 @@ class BaseAssistant {
       }
     }
 
-    if (!this.client) {
-      console.warn('[BaseAssistant] Cannot submit tool outputs: client not configured');
+    const provider = this.provider || null;
+    if (!provider || typeof provider.submitToolOutputs !== 'function') {
+      console.warn('[BaseAssistant] Cannot submit tool outputs: provider not configured');
       return outputs;
     }
 
-    await this.client.beta.threads.runs.submitToolOutputs(
-      run.thread_id,
-      run.id,
-      { tool_outputs: outputs }
-    );
+    await provider.submitToolOutputs({
+      threadId: run.thread_id || this.thread?.thread_id,
+      runId: run.id,
+      toolOutputs: outputs
+    });
 
     return outputs;
   }

package/lib/config/awsConfig.js

@@ -78,7 +78,7 @@ async function downloadFileFromS3(bucketName, key, downloadPath) {
   }
 }
 
-async function generatePresignedUrl(bucketName, key, expiration = 300) {
+async function generatePresignedUrl(bucketName, key, expiration = 3000) {
   const params = {
     Bucket: bucketName,
     Key: key,

package/lib/config/llmConfig.js

@@ -1,22 +1,27 @@
 const runtimeConfig = require('./runtimeConfig');
-const { OpenAIProvider } = require('../providers/OpenAIProvider');
+const { createProvider } = require('../providers/createProvider');
 
 let anthropicClient = null;
 let openaiClient = null;
-let openaiProviderInstance = null;
+let providerInstance = null;
+let providerVariant = 'assistants';
 
 const setOpenAIClient = (client) => {
   openaiClient = client || null;
   module.exports.openaiClient = openaiClient;
   if (!client) {
-    openaiProviderInstance = null;
-    module.exports.openaiProvider = null;
+    providerInstance = null;
+    module.exports.providerInstance = null;
+    providerVariant = 'assistants';
+    module.exports.providerVariant = providerVariant;
   }
 };
 
 const setOpenAIProvider = (provider) => {
-  openaiProviderInstance = provider || null;
-  module.exports.openaiProvider = openaiProviderInstance;
+  providerInstance = provider || null;
+  module.exports.providerInstance = providerInstance;
+  providerVariant = provider?.variant || providerVariant || 'assistants';
+  module.exports.providerVariant = providerVariant;
 
   if (!provider) {
     setOpenAIClient(null);
@@ -33,10 +38,10 @@ const setOpenAIProvider = (provider) => {
 };
 
 const getOpenAIProvider = ({ instantiate = true } = {}) => {
-  if (openaiProviderInstance) return openaiProviderInstance;
+  if (providerInstance) return providerInstance;
   if (!instantiate) return null;
   if (!openaiClient) return null;
-  const provider = new OpenAIProvider({ client: openaiClient });
+  const provider = createProvider({ client: openaiClient, variant: providerVariant });
   setOpenAIProvider(provider);
   return provider;
 };
@@ -69,7 +74,8 @@ const resolveAnthropicClient = () => {
 
 module.exports = {
   openaiClient,
-  openaiProvider: openaiProviderInstance,
+  providerInstance,
+  providerVariant,
   setOpenAIClient,
   setOpenAIProvider,
   getOpenAIProvider,

package/lib/controllers/assistantController.js

@@ -55,14 +55,7 @@ const createAssistantController = async (req, res) => {
   try {
     console.log('codes', codes);
     for (const code of codes) {
-      const thread = await Thread.findOne({ code: code });
-      if (thread !== null) {
-        await switchAssistant(code, assistant_id);
-        console.log('FORCE', force);
-        if (!force) continue;
-      }
-
-      await createAssistant(code, assistant_id, [...instrucciones, ...messages], thread);
+      await createAssistant(code, assistant_id, [...instrucciones, ...messages], force);
       console.log('messages', messages);
       for (const message of messages) {
         console.log('message', message);

package/lib/core/NexusMessaging.js

@@ -498,7 +498,8 @@ class NexusMessaging {
       if (response) {
         await this.sendMessage({
           code: from,
-          body: response
+          body: response,
+          processed: true
         });
       }
     } catch (error) {

package/lib/helpers/assistantHelper.js

@@ -7,6 +7,7 @@ const { convertPdfToImages } = require('./filesHelper.js');
 const { analyzeImage } = require('../helpers/llmsHelper.js');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
+const { createProvider } = require('../providers/createProvider');
 
 const fs = require('fs');
 const path = require('path');
@@ -17,11 +18,12 @@ const mode = process.env.NODE_ENV || 'dev';
 
 async function checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = 30) {
   try {
-    const provider = llmConfig.requireOpenAIProvider();
-    const run = await provider.getRun({ conversationId: thread_id, runId: run_id });
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    const run = await provider.getRun({ threadId: thread_id, runId: run_id });
     console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
 
-    if (run.status === 'failed' || run.status === 'expired' || run.status === 'incomplete') {
+    const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
+    if (failedStatuses.includes(run.status)) {
       console.log(`Run failed. ${run.status} `);
       console.log('Error:');
       console.log(run);
@@ -37,7 +39,7 @@ async function checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxR
       await assistant.handleRequiresAction(run);
       await new Promise(resolve => setTimeout(resolve, 5000));
       return checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries);
-    } else if (run.status !== 'completed') {
+    } else if (!['completed', 'succeeded'].includes(run.status)) {
       if (retryCount >= maxRetries) {
         return false;
       }
@@ -206,14 +208,13 @@ async function downloadMediaAndCreateFile(code, reply) {
   return fileNames;
 }
 
-async function processIndividualMessage(code, reply, thread) {
+async function processIndividualMessage(code, reply, provider, thread) {
+  const tempFiles = [];
   try {
-    const provider = llmConfig.requireOpenAIProvider();
     const formattedMessage = formatMessage(reply);
     console.log('[processIndividualMessage] formattedMessage:', formattedMessage);
     const isNotAssistant = !reply.from_me;
     let messagesChat = [];
-    let attachments = [];
     let url = null;
 
     if (formattedMessage) {
@@ -224,6 +225,7 @@ async function processIndividualMessage(code, reply, thread) {
     if (reply.is_media) {
       console.log('IS MEDIA', reply.is_media);
       const fileNames = await downloadMediaAndCreateFile(code, reply);
+      tempFiles.push(...fileNames);
       for (const fileName of fileNames) {
         console.log(fileName);
         // Skip WBMP images and stickers
@@ -255,13 +257,17 @@ async function processIndividualMessage(code, reply, thread) {
             });
           } else {
             console.log('Add attachment');
-            const file = await provider.uploadFile({
+            /*const file = await provider.uploadFile({
               file: fs.createReadStream(fileName),
               purpose: 'vision',
             });
             messagesChat.push({
               type: 'image_file',
               image_file: { file_id: file.id },
+            });*/
+            messagesChat.push({
+              type: 'text',
+              text: imageAnalysis.description,
             });
           }
         } else if (fileName.includes('audio')) {
@@ -271,7 +277,6 @@ async function processIndividualMessage(code, reply, thread) {
             language: 'es'
           });
           const transcriptText = audioTranscript?.text || audioTranscript;
-          console.log('Inside AUDIO', transcriptText);
           messagesChat.push({
             type: 'text',
             text: transcriptText,
@@ -280,30 +285,40 @@ async function processIndividualMessage(code, reply, thread) {
       }
     }
 
-    console.log('messagesChat', messagesChat);
-    console.log('[processIndividualMessage] attachments:', attachments);
-    console.log('[processIndividualMessage] formattedMessage:', formattedMessage);
-
+    console.log('[processIndividualMessage] messagesChat', messagesChat);
 
     // ONLY add user messages to the thread
+    const threadId = process.env.VARIANT === 'responses' ? thread?.conversation_id : thread?.thread_id;
     if (isNotAssistant) {
+      console.log('Adding user message to thread', thread);
       await provider.addMessage({
-        conversationId: thread.thread_id,
+        threadId,
         role: 'user',
-        content: messagesChat,
-        attachments: attachments
+        content: messagesChat
       });
       console.log('[processIndividualMessage] User message added to thread');
     }
 
     await Message.updateOne(
       { message_id: reply.message_id, timestamp: reply.timestamp },
-      { $set: { assistant_id: thread.assistant_id, thread_id: thread.thread_id } }
+      { $set: { assistant_id: thread.assistant_id, thread_id: threadId } }
     );
 
     return {isNotAssistant, url};
   } catch (err) {
     console.log(`Error inside process message ${err}`);
+  } finally {
+    if (tempFiles.length > 0) {
+      await Promise.all(tempFiles.map(async (filePath) => {
+        try {
+          await fs.promises.unlink(filePath);
+        } catch (error) {
+          if (error?.code !== 'ENOENT') {
+            console.warn('[processIndividualMessage] Failed to remove temp file:', filePath, error?.message || error);
+          }
+        }
+      }));
+    }
   }
 }
 

package/lib/helpers/llmsHelper.js

@@ -42,6 +42,33 @@ async function analyzeImage(imagePath) {
     const imageBuffer = await fs.promises.readFile(imagePath);
     const base64Image = imageBuffer.toString('base64');
 
+    // Descrciption of the image
+    const imageDescription = 'Describe the image in detail.';
+    const messageDescription = await anthropicClient.messages.create({
+      model: 'claude-3-7-sonnet-20250219',
+      max_tokens: 1024,
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: mimeType,
+                data: base64Image,
+              },
+            },
+            {
+              type: 'text',
+              text: imageDescription,
+            },
+          ],
+        },
+      ],
+    });
+    const description = messageDescription.content[0].text;
+
     // Create a more specific prompt for table detection and extraction
     const tablePrompt = `Please analyze this image and respond in the following format:
 1. First, determine if there is a table in the image.
@@ -187,8 +214,8 @@ Ejemplo 1:
     const isTable = (table === null) ? false : true;
     const isRelevant = (messageRelevanceStr.includes('YES')) ? true : false;
 
-    return {medical_analysis: messageAnalysisStr, medical_relevance: isRelevant, 
-      has_table: isTable, table_data: table};
+    return {description: description, medical_analysis: messageAnalysisStr, 
+      medical_relevance: isRelevant, has_table: isTable, table_data: table};
   } catch (error) {
     console.error('Error analyzing image:', error);
     throw error;

package/lib/index.js

@@ -1,7 +1,9 @@
 const { NexusMessaging, setDefaultInstance } = require('./core/NexusMessaging');
 const { MongoStorage } = require('./storage/MongoStorage');
 const { MessageParser } = require('./utils/messageParser');
-const { DefaultLLMProvider } = require('./utils/defaultLLMProvider');
+const { createProvider } = require('./providers/createProvider');
+const { OpenAIAssistantsProvider } = require('./providers/OpenAIAssistantsProvider');
+const { OpenAIResponsesProvider } = require('./providers/OpenAIResponsesProvider');
 const { loadNexusConfig } = require('./config/configLoader');
 const templateController = require('./controllers/templateController');
 const templateFlowController = require('./controllers/templateFlowController');
@@ -9,14 +11,13 @@ const interactive = require('./interactive');
 const runtimeConfig = require('./config/runtimeConfig');
 const llmConfigModule = require('./config/llmConfig');
 const {
-  configureLLMProvider: configureAssistantsLLM,
   registerAssistant,
   overrideGetAssistantById,
   configureAssistants: setAssistantsConfig
 } = require('./services/assistantService');
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
-const { BaseAssistant: CoreBaseAssistant } = require('./assistants/BaseAssistant');
+const { BaseAssistant } = require('./assistants/BaseAssistant');
 const {
   setPreprocessingHandler,
   hasPreprocessingHandler,
@@ -134,16 +135,14 @@ class Nexus {
 
     // Initialize default LLM provider if requested
     if (llm === 'openai') {
-      this.llmProvider = new DefaultLLMProvider(llmConfig);
       try {
-        const providerInstance = typeof this.llmProvider.getProvider === 'function'
-          ? this.llmProvider.getProvider()
-          : null;
+        const providerInstance = createProvider(llmConfig);
+        this.llmProvider = providerInstance;
 
         if (providerInstance && typeof llmConfigModule.setOpenAIProvider === 'function') {
           llmConfigModule.setOpenAIProvider(providerInstance);
-        } else if (typeof this.llmProvider.getClient === 'function' && typeof llmConfigModule.setOpenAIClient === 'function') {
-          llmConfigModule.setOpenAIClient(this.llmProvider.getClient());
+        } else if (providerInstance?.getClient && typeof llmConfigModule.setOpenAIClient === 'function') {
+          llmConfigModule.setOpenAIClient(providerInstance.getClient());
         }
       } catch (err) {
         console.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
@@ -175,15 +174,7 @@ class Nexus {
     const assistantsConfig = assistantsOpt || assistantOpt;
     try {
       if (this.llmProvider && typeof configureAssistantsLLM === 'function') {
-        const providerInstance = typeof this.llmProvider.getProvider === 'function'
-          ? this.llmProvider.getProvider()
-          : null;
-
-        if (providerInstance) {
-          configureAssistantsLLM(providerInstance);
-        } else if (typeof this.llmProvider.getClient === 'function') {
-          configureAssistantsLLM(this.llmProvider.getClient());
-        }
+        configureAssistantsLLM(this.llmProvider);
       }
       if (assistantsConfig) {
         if (assistantsConfig.registry && typeof assistantsConfig.registry === 'object') {
@@ -313,7 +304,7 @@ class Nexus {
 
   /**
    * Get LLM provider instance
-   * @returns {DefaultLLMProvider|null} LLM provider instance
+   * @returns {Object|null} LLM provider instance
    */
   getLLMProvider() {
     return this.llmProvider;
@@ -330,11 +321,11 @@ module.exports = {
   BaileysProvider,
   MongoStorage,
   MessageParser,
-  DefaultLLMProvider,
-  OpenAIProvider: require('./providers/OpenAIProvider').OpenAIProvider,
-  BaseAssistant: CoreBaseAssistant,
+  createProvider,
+  OpenAIAssistantsProvider,
+  OpenAIResponsesProvider,
+  BaseAssistant,
   registerAssistant,
-  configureAssistantsLLM,
   overrideGetAssistantById,
   configureAssistants: setAssistantsConfig,
   setPreprocessingHandler,

package/lib/models/messageModel.js

@@ -47,7 +47,7 @@ const messageSchema = new mongoose.Schema({
   }
 }, { timestamps: true });
 
-messageSchema.index({ message_id: 1, body: 1 }, { unique: true });
+messageSchema.index({ message_id: 1, timestamp: 1 }, { unique: true });
 
 messageSchema.pre('save', function (next) {
   if (this.timestamp) {
@@ -75,10 +75,11 @@ async function insertMessage(values) {
       group_id: values.group_id,
       reply_id: values.reply_id,
       from_me: values.from_me,
-      processed: skipNumbers.includes(values.numero),
+      processed: values.processed || skipNumbers.includes(values.numero),
       media: values.media ? values.media : null,
       content_sid: values.content_sid || null
     };
+    console.log('Inserting message', messageData);
 
     await Message.findOneAndUpdate(
       { message_id: values.message_id, body: values.body },
@@ -113,7 +114,7 @@ function getMessageValues(message, content, reply, is_media) {
   const group_id = is_group ? message.key.remoteJid : null;
   const reply_id = reply || null;
   const from_me = message.key.fromMe;
-
+  
   return {
     nombre_whatsapp,
     numero,

package/lib/models/threadModel.js

@@ -3,6 +3,8 @@ const mongoose = require('mongoose');
 const threadSchema = new mongoose.Schema({
   code: { type: String, required: true },
   assistant_id: { type: String, required: true },
+  conversation_id: { type: String, required: true },
+  prompt_id: { type: String, default: null },
   thread_id: { type: String, required: true },
   patient_id: { type: String, default: null },
   run_id: { type: String, default: null },
@@ -14,6 +16,7 @@ const threadSchema = new mongoose.Schema({
 
 threadSchema.index({ code: 1, active: 1 });
 threadSchema.index({ thread_id: 1 });
+threadSchema.index({ conversation_id: 1 });
 
 const Thread = mongoose.model('Thread', threadSchema);