@peopl-health/nexus 1.7.12 → 2.0.1

package/lib/services/assistantService.js

@@ -1,37 +1,23 @@
 const { Historial_Clinico_ID } = require('../config/airtableConfig.js');
 const AWS = require('../config/awsConfig.js');
-const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
-const runtimeConfig = require('../config/runtimeConfig');
 const llmConfig = require('../config/llmConfig');
+const runtimeConfig = require('../config/runtimeConfig');
 const { BaseAssistant } = require('../assistants/BaseAssistant');
-const { OpenAIProvider } = require('../providers/OpenAIProvider');
-
-const configureLLMProvider = (provider) => {
-  if (!provider) {
-    throw new Error('configureLLMProvider requires an OpenAI provider or raw client');
-  }
-
-  if (provider instanceof OpenAIProvider || typeof provider.runConversation === 'function') {
-    llmConfig.setOpenAIProvider(provider);
-    return provider;
-  }
-
-  const wrappedProvider = new OpenAIProvider({ client: provider });
-  llmConfig.setOpenAIProvider(wrappedProvider);
-  return wrappedProvider;
-};
-
-let assistantConfig = null;
-let assistantRegistry = {};
-let customGetAssistantById = null;
+const { createProvider } = require('../providers/createProvider');
 
 const { Message, formatTimestamp } = require('../models/messageModel.js');
 const { Thread } = require('../models/threadModel.js');
 
 const { checkRunStatus, getCurRow } = require('../helpers/assistantHelper.js');
 const { processIndividualMessage, getLastMessages } = require('../helpers/assistantHelper.js');
+const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { delay } = require('../helpers/whatsappHelper.js');
 
+let assistantConfig = null;
+let assistantRegistry = {};
+let customGetAssistantById = null;
+
+
 const configureAssistants = (config) => {
   if (!config) {
     throw new Error('Assistant configuration is required');
@@ -44,53 +30,61 @@ const runAssistantAndWait = async ({
   assistant,
   runConfig = {}
 }) => {
-  if (!thread || !thread.thread_id) {
-    throw new Error('runAssistantAndWait requires a thread with a valid thread_id');
+  if (!thread || !(thread.thread_id || thread.conversation_id)) {
+    throw new Error('runAssistantAndWait requires a thread with a valid thread_id or conversation_id');
   }
 
   if (!assistant) {
     throw new Error('runAssistantAndWait requires an assistant instance');
   }
 
-  const provider = llmConfig.requireOpenAIProvider();
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   const { polling, ...conversationConfig } = runConfig || {};
 
   const run = await provider.runConversation({
-    conversationId: thread.thread_id,
-    assistantId: thread.assistant_id,
+    threadId: thread?.thread_id,
+    conversationId: thread?.conversation_id,
+    assistantId: thread?.assistant_id,
+    promptId: thread?.prompt_id,
     ...conversationConfig,
   });
 
-  const filter = thread.code ? { code: thread.code, active: true } : null;
-  if (filter) {
-    await Thread.updateOne(filter, { $set: { run_id: run.id } });
-  }
+  let output = null;
+  if (thread?.thread_id) {
+    const filter = thread.code ? { code: thread.code, active: true } : null;
+    if (filter) {
+      await Thread.updateOne(filter, { $set: { run_id: run.id } });
+    }
 
-  const maxRetries = polling?.maxRetries ?? 30;
-  let completed = false;
+    const maxRetries = polling?.maxRetries ?? 30;
+    let completed = false;
 
-  try {
-    completed = await checkRunStatus(assistant, run.thread_id, run.id, 0, maxRetries);
-  } finally {
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: null } });
+    try {
+      console.log('RUN ID', run.id, thread.thread_id);
+      completed = await checkRunStatus(assistant, thread.thread_id, run.id, 0, maxRetries);
+    } finally {
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: null } });
+      }
     }
-  }
 
-  let finalRun = run;
-  try {
-    finalRun = await provider.getRun({ conversationId: run.thread_id, runId: run.id });
-  } catch (error) {
-    console.warn('Warning: unable to retrieve final run state:', error?.message || error);
-  }
+    let finalRun = run;
+    try {
+      finalRun = await provider.getRun({ threadId: run.thread_id, runId: run.id });
+    } catch (error) {
+      console.warn('Warning: unable to retrieve final run state:', error?.message || error);
+    }
 
-  if (!completed) {
-    return { run: finalRun, completed: false, output: '' };
-  }
+    if (!completed) {
+      return { run: finalRun, completed: false, output: '' };
+    }
 
-  const output = await provider.getRunText({ conversationId: run.thread_id, runId: run.id, fallback: '' });
+    output = await provider.getRunText({ threadId: run.thread_id, runId: run.id, fallback: '' });
+  } else {
+    output = run.output_text;
+  }
 
-  return { run: finalRun, completed: true, output };
+  return { completed: true, output };
 };
 
 const registerAssistant = (assistantId, definition) => {
@@ -171,7 +165,7 @@ const getAssistantById = (assistant_id, thread) => {
     throw new Error(`Assistant '${assistant_id}' not found. Available assistants: ${Object.keys(assistantRegistry).join(', ')}`);
   }
 
-  const provider = llmConfig.getOpenAIProvider({ instantiate: false });
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   const sharedClient = provider?.getClient?.() || llmConfig.openaiClient || null;
 
   if (AssistantClass.prototype instanceof BaseAssistant) {
@@ -196,10 +190,11 @@ const getAssistantById = (assistant_id, thread) => {
 };
 
 
-const createAssistant = async (code, assistant_id, messages=[], prevThread=null) => {
+const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   // If thread already exists, update it
   const findThread = await Thread.findOne({ code: code });
-  if (findThread) {
+  const variant = process.env.VARIANT || 'assistants';
+  if ((findThread?.conversation_id && variant === 'responses') || (findThread?.thread_id && variant === 'assistants')) {
     await Thread.updateOne({ code: code }, { $set: { active: true, stopped: false, assistant_id: assistant_id } });
     return findThread;
   }
@@ -213,34 +208,40 @@ const createAssistant = async (code, assistant_id, messages=[], prevThread=null)
   const initialThread = await assistant.create(code, curRow[0]);
 
   // Add new messages to memory
-  const provider = llmConfig.requireOpenAIProvider();
+  const provider = createProvider({ variant: variant || 'assistants' });
   for (const message of messages) {
     await provider.addMessage({
-      conversationId: initialThread.id,
+      threadId: initialThread.id,
       role: 'assistant',
       content: message
     });
   }
-    
+  
+  console.log('initialThread', initialThread);
   // Define new thread data
   const thread = {
     code: code,
-    assistant_id: assistant_id,
-    thread_id: initialThread.id,
+    assistant_id: assistant_id.startsWith('assistant') ? assistant_id : null,
+    thread_id: initialThread.id.startsWith('thread') ? initialThread.id : null,
+    conversation_id: initialThread.id.startsWith('conv') ? initialThread.id : null,
+    prompt_id: assistant_id.startsWith('pmpt') ? assistant_id : null,
     patient_id: patientId,
-    run_id: null,
     nombre: nombre,
     active: true
   };
 
-  const condition = { thread_id: prevThread?.thread_id };
+  const updateData = Object.fromEntries(
+    Object.entries(thread).filter(([_, v]) => v != null)
+  );
+
+  const condition = { $or: [{ thread_id: findThread?.thread_id }, { conversation_id: findThread?.conversation_id }] };
   const options = { new: true, upsert: true };
-  const updatedThread = await Thread.findOneAndUpdate(condition, thread, options);
+  const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...updateData}, options);
   console.log('Updated thread:', updatedThread);
 
   // Delete previous thread
-  if (prevThread) {
-    await provider.deleteConversation(prevThread.thread_id);
+  if (force) {
+    await provider.deleteConversation(findThread.conversation_id || findThread.thread_id);
   }
 
   return thread;
@@ -252,12 +253,11 @@ const addMsgAssistant = async (code, inMessages, reply = false) => {
     console.log(thread);
     if (thread === null) return null;
 
-    const provider = llmConfig.requireOpenAIProvider();
-
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     for (const message of inMessages) {
       console.log(message);
       await provider.addMessage({
-        conversationId: thread.thread_id,
+        threadId: thread.conversation_id || thread.thread_id,
         role: 'assistant',
         content: message
       });
@@ -265,7 +265,7 @@ const addMsgAssistant = async (code, inMessages, reply = false) => {
 
     if (!reply) return null;
 
-    const assistant = getAssistantById(thread.assistant_id, thread);
+    const assistant = getAssistantById(thread?.prompt_id || thread?.assistant_id, thread);
     const { output } = await runAssistantAndWait({ thread, assistant });
     console.log('THE ANS IS', output);
 
@@ -282,7 +282,7 @@ const addInsAssistant = async (code, instruction) => {
     console.log(thread);
     if (thread === null) return null;
 
-    const assistant = getAssistantById(thread.assistant_id, thread);
+    const assistant = getAssistantById(thread?.prompt_id || thread?.assistant_id, thread);
     const { output } = await runAssistantAndWait({
       thread,
       assistant,
@@ -317,11 +317,11 @@ const getThread = async (code, message = null) => {
       return null;
     }
 
-    const provider = llmConfig.getOpenAIProvider({ instantiate: false });
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     while (thread && thread.run_id) {
       console.log(`Wait for ${thread.run_id} to be executed`);
       const activeProvider = provider || llmConfig.requireOpenAIProvider();
-      const run = await activeProvider.getRun({ conversationId: thread.thread_id, runId: thread.run_id });
+      const run = await activeProvider.getRun({ threadId: thread.conversation_id || thread.thread_id, runId: thread.run_id });
       if (run.status === 'cancelled' || run.status === 'expired' || run.status === 'completed') {
         await Thread.updateOne({ code: code }, { $set: { run_id: null } });
       }
@@ -353,28 +353,28 @@ const replyAssistant = async function (code, message_ = null, thread_ = null, ru
     if (!thread || !thread.active) return null;
 
     const patientReply = await getLastMessages(code);
-    console.log('UNREAD DATA', patientReply);
     if (!patientReply) {
       console.log('No relevant data found for this assistant.');
       return null;
     }
 
-    const provider = llmConfig.requireOpenAIProvider();
-
-    let activeRuns = await provider.listRuns({ conversationId: thread.thread_id, activeOnly: true });
-    let activeRunsCount = activeRuns?.data?.length || 0;
-    console.log('ACTIVE RUNS:', activeRunsCount, activeRuns?.data?.map(run => ({ id: run.id, status: run.status })));
-    while (activeRunsCount > 0) {
-      console.log(`WAITING FOR ${activeRunsCount} ACTIVE RUNS TO COMPLETE - ${thread.thread_id}`);
-      activeRuns = await provider.listRuns({ conversationId: thread.thread_id, activeOnly: true });
-      activeRunsCount = activeRuns?.data?.length || 0;
-      await delay(5000);
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    if (!(thread?.conversation_id)) {
+      let activeRuns = await provider.listRuns({ threadId: thread.thread_id, activeOnly: true });
+      let activeRunsCount = activeRuns?.data?.length || 0;
+      console.log('ACTIVE RUNS:', activeRunsCount, activeRuns?.data?.map(run => ({ id: run.id, status: run.status })));
+      while (activeRunsCount > 0) {
+        console.log(`WAITING FOR ${activeRunsCount} ACTIVE RUNS TO COMPLETE - ${thread.thread_id}`);
+        activeRuns = await provider.listRuns({ threadId: thread.thread_id, activeOnly: true });
+        activeRunsCount = activeRuns?.data?.length || 0;
+        await delay(5000);
+      }
     }
 
     let patientMsg = false;
     let urls = [];
     for (const reply of patientReply) {
-      const { isNotAssistant, url } = await processIndividualMessage(code, reply, thread);
+      const { isNotAssistant, url } = await processIndividualMessage(code, reply, provider, thread);
       console.log(`isNotAssistant ${isNotAssistant} ${url}`);
       patientMsg = patientMsg || isNotAssistant;
       if (url) urls.push({ 'url': url });
@@ -390,15 +390,13 @@ const replyAssistant = async function (code, message_ = null, thread_ = null, ru
         await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
       }
       if (processedFiles && processedFiles.length) {
-        await cleanupFiles(processedFiles);
+        cleanupFiles(processedFiles);
       }
     }
 
-    thread = await getThread(code);
-    console.log('THREAD STOPPED', code, thread?.stopped);
-    if (!patientMsg || !thread || thread?.stopped) return null;
+    if (!patientMsg) return null;
 
-    const assistant = getAssistantById(thread.assistant_id, thread);
+    const assistant = getAssistantById(process.env.VARIANT === 'responses' ? thread?.prompt_id : thread?.assistant_id, thread);
     assistant.setReplies(patientReply);
 
     const { run, output, completed } = await runAssistantAndWait({
@@ -440,7 +438,6 @@ module.exports = {
   switchAssistant,
   configureAssistants,
   registerAssistant,
-  configureLLMProvider,
   overrideGetAssistantById,
   runAssistantAndWait
 };

package/lib/storage/MongoStorage.js

@@ -61,17 +61,9 @@ class MongoStorage {
 
   async saveMessage(messageData) {
     try {
-      console.log('[MongoStorage] saveMessage called', {
-        code: messageData?.to || messageData?.code || messageData?.numero,
-        from: messageData?.from,
-        provider: messageData?.provider || 'unknown',
-        hasRaw: Boolean(messageData?.raw),
-        hasMedia: Boolean(messageData?.media || messageData?.fileUrl),
-        hasContentSid: Boolean(messageData?.contentSid),
-        is_interactive: messageData.isInteractive,
-        interaction_type: messageData.interactionType
-      });
+      console.log('[MongoStorage] Saving message', messageData);
       const enrichedMessage = await this._enrichTwilioMedia(messageData);
+      console.log('[MongoStorage] Enriched message', enrichedMessage);
       const values = this.buildMessageValues(enrichedMessage);
       const { insertMessage } = require('../models/messageModel');
       await insertMessage(values);
@@ -179,6 +171,7 @@ class MongoStorage {
     const now = new Date();
     const timestamp = now.toISOString();
     const nombre = messageData.nombre_whatsapp || messageData.author || messageData.fromName || runtimeConfig.get('USER_DB_MONGO') || process.env.USER_DB_MONGO || 'Nexus';
+    const processed = messageData.processed || false;
     
     // Use message body directly (template rendering is now handled by the provider)
     let textBody = messageData.body;
@@ -204,6 +197,7 @@ class MongoStorage {
       numero: normalizedNumero,
       body: textBody,
       timestamp,
+      processed,
       message_id: providerId,
       is_group: isGroup,
       is_media: isMedia,

package/lib/utils/index.js

@@ -1,9 +1,7 @@
-const { DefaultLLMProvider } = require('./defaultLLMProvider');
 const { MessageParser } = require('./messageParser');
 const { logger } = require('./logger');
 
 module.exports = {
-  DefaultLLMProvider,
   MessageParser,
   logger
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.7.12",
+  "version": "2.0.1",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -93,7 +93,7 @@
     "@anthropic-ai/sdk": "^0.32.0",
     "baileys": "^6.4.0",
     "express": "4.21.2",
-    "openai": "^4.0.0",
+    "openai": "6.2.0",
     "twilio": "5.6.0"
   },
   "engines": {

package/lib/utils/defaultLLMProvider.js

@@ -1,20 +0,0 @@
-const { OpenAIProvider } = require('../providers/OpenAIProvider');
-
-/**
- * Default LLM Provider using OpenAI
- */
-class DefaultLLMProvider {
-  constructor(config = {}) {
-    this.provider = new OpenAIProvider(config);
-  }
-
-  getProvider() {
-    return this.provider;
-  }
-
-  getClient() {
-    return this.provider.getClient();
-  }
-}
-
-module.exports = { DefaultLLMProvider };