@peopl-health/nexus 2.4.13 → 2.5.1-fix

package/examples/basic-usage.js

@@ -9,8 +9,59 @@ app.use(express.json());
 class GeneralAssistant extends BaseAssistant {
   constructor(options = {}) {
     super(options);
-    // You can add custom tools or setup here
-    // Example: this.registerTool('toolName', schema, handler);
+    // Register the reportUnresolvedRequests tool for testing
+    this.registerTool({
+      name: 'reportUnresolvedRequests',
+      definition: {
+        description: 'Identifica preguntas o síntomas que no se resolvieron completamente o que fueron escaladas al equipo médico.',
+        strict: false,
+        parameters: {
+          type: 'object',
+          required: [
+            'unresolvedQuestion',
+            'escalationDetails'
+          ],
+          properties: {
+            unresolvedQuestion: {
+              type: 'string',
+              description: 'La pregunta o síntoma que quedó sin resolver.'
+            },
+            escalationDetails: {
+              type: 'string',
+              description: 'Detalles sobre por qué se escaló o a quién fue escalada (equipo médico, etc.).'
+            },
+            resolutionAttempted: {
+              type: 'boolean',
+              description: 'Indica si se intentó ofrecer una resolución antes de escalar.'
+            },
+            triggerConditions: {
+              type: 'object',
+              description: 'Condiciones que activan la función cuando se detecta una pregunta o síntoma no resuelto en su totalidad.',
+              properties: {
+                responseAnalysis: {
+                  type: 'string',
+                  description: 'Análisis de la respuesta para determinar si es suficientemente específica o resuelve la pregunta.',
+                  default: 'La respuesta contiene palabras como \'depende\', \'consulte a su equipo médico\', \'varía según el caso\', \'haremos las consultas al equipo médico de PEOPL\', \'puedo comunicarme con el equipo médico de PEOPL para ti\', \'Voy a escalar la consulta al equipo médico\' o no proporciona un plan de acción claro.'
+                }
+              },
+              required: [
+                'responseAnalysis'
+              ]
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      handler: async (args) => {
+        // Handler for testing - logs the unresolved request information
+        console.log('🔍 [reportUnresolvedRequests] Tool called with:', JSON.stringify(args, null, 2));
+        return {
+          success: true,
+          message: 'Unresolved request reported successfully',
+          data: args
+        };
+      }
+    });
   }
 }
 
@@ -35,7 +86,7 @@ async function startServer() {
     providerConfig: {
       accountSid: process.env.TWILIO_ACCOUNT_SID,
       authToken: process.env.TWILIO_AUTH_TOKEN,
-      whatsappNumber: process.env.TWILIO_WHATSAPP_NUMBER
+      whatsappNumber: process.env.TWILIO_WHATSAPP_NUMBER,
     },
 
     // Media configuration for AWS S3 upload
@@ -56,6 +107,8 @@ async function startServer() {
         // Register the general assistant with its OpenAI assistant ID
         'asst_O6mAXAhf0xyVj3t4DHRs26uT': GeneralAssistant,
         'pmpt_68f844cd975481979c080431bde74f6e0adf01a52110813b': GeneralAssistant,
+        'pmpt_68f8059adc7881938477ddbfb6e0d1970c2ed91d30c64be6': GeneralAssistant,
+        'pmpt_68f649ce39ec81908fade27434c167e6014528b0dc5469c6': GeneralAssistant,
       }
     }
   });
@@ -75,6 +128,25 @@ async function startServer() {
     }
   });
 
+  // Add status callback endpoint for Twilio message status updates
+  // Twilio sends form-encoded data, so we need urlencoded middleware
+  const { handleStatusCallback } = require('../lib/helpers/messageStatusHelper');
+  app.use('/twilio/status_callback', express.urlencoded({ extended: true }));
+  app.post('/twilio/status_callback', async (req, res) => {
+    try {
+      const updated = await handleStatusCallback(req.body);
+      if (updated) {
+        console.log('✅ Status updated:', req.body.MessageSid, req.body.MessageStatus);
+        res.status(200).json({ success: true, message: 'Status updated' });
+      } else {
+        res.status(200).json({ success: false, message: 'Message not found' });
+      }
+    } catch (error) {
+      console.error('Status callback error:', error);
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
   // Custom endpoint example
   app.get('/status', (req, res) => {
     res.json({
@@ -107,6 +179,7 @@ async function startServer() {
     console.log('Available endpoints:');
     console.log('- POST /webhook - Webhook for incoming messages');
     console.log('- POST /twilio/webhook - Twilio webhook for incoming messages');
+    console.log('- POST /twilio/status_callback - Twilio status callback for message delivery status');
     console.log('- GET /status - Connection status');
     console.log('- GET /airtable-test - Test Airtable connection');
     console.log('- GET /media-test - Test AWS media upload configuration');
@@ -117,6 +190,11 @@ async function startServer() {
     console.log('   - Multiple messages from same sender will be batched');
     console.log('   - Use test-batching.js to test the functionality');
     console.log('');
+    console.log('🧪 Assistant Testing:');
+    console.log('   - Use test-assistant.js to test assistant functionality');
+    console.log('   - Run: node examples/test-assistant.js');
+    console.log('   - Tests basic messages, responses, batching, and retry logic');
+    console.log('');
     console.log('📸 Media Upload Setup:');
     console.log('   Add these to your .env file for media upload:');
     console.log('   - AWS_ACCESS_KEY_ID=your_access_key');

package/lib/adapters/TwilioProvider.js

@@ -18,6 +18,7 @@ class TwilioProvider extends MessageProvider {
     this.accountSid = config.accountSid;
     this.authToken = config.authToken;
     this.whatsappNumber = config.whatsappNumber;
+    this.statusCallbackUrl = config.statusCallbackUrl || null;
   }
 
   async initialize() {
@@ -61,6 +62,17 @@ class TwilioProvider extends MessageProvider {
       to: formattedCode
     };
 
+    if (this.statusCallbackUrl) {
+      messageParams.statusCallback = this.statusCallbackUrl;
+      messageParams.statusCallbackMethod = messageData.statusCallbackMethod || 'POST';
+      logger.info('[TwilioProvider] Message will use status callback', {
+        callbackUrl: this.statusCallbackUrl,
+        method: messageParams.statusCallbackMethod
+      });
+    } else {
+      logger.debug('[TwilioProvider] No status callback URL configured');
+    }
+
     // Handle template messages
     if (contentSid) {
       const renderedMessage = await this.renderTemplate(contentSid, variables);
@@ -118,17 +130,23 @@ class TwilioProvider extends MessageProvider {
             provider: 'twilio',
             timestamp: new Date(),
             fromMe: true,
-            processed: messageData.processed !== undefined ? messageData.processed : false
+            processed: messageData.processed !== undefined ? messageData.processed : false,
+            statusInfo: {
+              status: result.status ? result.status.toLowerCase() : null,
+              updatedAt: result.dateCreated || new Date()
+            }
           });
           logger.info('[TwilioProvider] Message persisted successfully', { messageId: result.sid });
         } catch (storageError) {
           logger.error('TwilioProvider storage failed:', storageError);
         }
       }
+      
       return {
         success: true,
         messageId: result.sid,
         provider: 'twilio',
+        status: result.status,
         result
       };
     } catch (error) {
@@ -136,6 +154,41 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
+  async sendTypingIndicator(messageId) {
+    try {      
+      const response = await axios.post(
+        'https://messaging.twilio.com/v2/Indicators/Typing.json',
+        new URLSearchParams({
+          messageId: messageId,
+          channel: 'whatsapp'
+        }),
+        {
+          auth: {
+            username: this.accountSid,
+            password: this.authToken
+          },
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        }
+      );
+      logger.info('[TwilioProvider] Typing indicator sent successfully', { 
+        messageId, 
+        success: response.data?.success,
+        status: response.status 
+      });
+      return { success: true };
+    } catch (error) {
+      logger.error('[TwilioProvider] Failed to send typing indicator', { 
+        error: error.message, 
+        messageId,
+        status: error.response?.status,
+        data: error.response?.data
+      });
+      return { success: false };
+    }
+  }
+
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
     const delay = this.calculateDelay(sendTime, timeZone);
@@ -215,7 +268,6 @@ class TwilioProvider extends MessageProvider {
         const payload = scheduledMessage.toObject ? scheduledMessage.toObject() : { ...scheduledMessage };
         delete payload.__nexusSend;
         
-        // Map message field to body for consistency (scheduled messages use 'message' field)
         if (payload.message && !payload.body) {
           payload.body = payload.message;
         }
@@ -681,6 +733,30 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
+  /**
+   * Check the status of a sent message using its SID
+   */
+  async getMessageStatus(messageSid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!messageSid) {
+      throw new Error('Message SID is required');
+    }
+
+    try {
+      const message = await this.twilioClient.messages(messageSid).fetch();
+      // Returns the complete Twilio message object with all status information
+      // Status-related fields: status, errorCode, errorMessage, dateCreated, dateSent, dateUpdated
+      return message;
+    } catch (error) {
+      if (error.status === 404) {
+        throw new Error(`Message with SID ${messageSid} not found`);
+      }
+      throw new Error(`Failed to fetch message status: ${error.message}`);
+    }
+  }
+
 }
 
 module.exports = { TwilioProvider };

package/lib/controllers/messageStatusController.js

@@ -0,0 +1,92 @@
+const { handleStatusCallback, getMessageStatus } = require('../helpers/messageStatusHelper');
+const { logger } = require('../utils/logger');
+
+/**
+ * Handle Twilio status callback webhook
+ * POST /api/message/status-callback
+ */
+async function messageStatusCallbackController(req, res) {
+  try {
+    logger.info('[MessageStatusController] Received status callback', {
+      method: req.method,
+      path: req.path,
+      headers: req.headers['content-type'],
+      bodyKeys: Object.keys(req.body || {}),
+      body: req.body
+    });
+    
+    const updated = await handleStatusCallback(req.body);
+
+    if (updated) {
+      logger.info('[MessageStatusController] Status updated successfully', {
+        messageSid: req.body.MessageSid,
+        status: req.body.MessageStatus
+      });
+      res.status(200).json({
+        success: true,
+        message: 'Status updated',
+        messageSid: req.body.MessageSid,
+        status: req.body.MessageStatus
+      });
+    } else {
+      res.status(200).json({
+        success: false,
+        message: 'Message not found or invalid data',
+        messageSid: req.body.MessageSid
+      });
+    }
+  } catch (error) {
+    logger.error('[MessageStatusController] Error handling status callback', {
+      error: error.message,
+      body: req.body
+    });
+    res.status(500).json({
+      success: false,
+      error: 'Failed to process status callback'
+    });
+  }
+}
+
+/**
+ * Get message status from database
+ * GET /api/message/status/:messageSid
+ */
+async function getMessageStatusController(req, res) {
+  try {
+    const { messageSid } = req.params;
+    
+    const message = await getMessageStatus(messageSid);
+
+    if (message) {
+      res.status(200).json({
+        success: true,
+        message: {
+          messageSid: message.message_id,
+          statusInfo: message.statusInfo || null,
+          numero: message.numero,
+          body: message.body
+        }
+      });
+    } else {
+      res.status(404).json({
+        success: false,
+        error: 'Message not found'
+      });
+    }
+  } catch (error) {
+    logger.error('[MessageStatusController] Error fetching message status', {
+      error: error.message,
+      messageSid: req.params.messageSid
+    });
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch message status'
+    });
+  }
+}
+
+module.exports = {
+  messageStatusCallbackController,
+  getMessageStatusController
+};
+

package/lib/core/NexusMessaging.js

@@ -1,4 +1,5 @@
 const { airtable, getBase } = require('../config/airtableConfig');
+const { Message } = require('../models/messageModel');
 const { addMsgAssistant, replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
 const runtimeConfig = require('../config/runtimeConfig');
@@ -42,8 +43,7 @@ class NexusMessaging {
     this.pendingResponses = new Map();
     this.batchingConfig = {
       enabled: config.messageBatching?.enabled ?? false,
-      baseWaitTime: config.messageBatching?.baseWaitTime ?? 15000,
-      randomVariation: config.messageBatching?.randomVariation ?? 5000
+      baseWaitTime: config.messageBatching?.baseWaitTime ?? 10000
     };
   }
 
@@ -373,6 +373,17 @@ class NexusMessaging {
     } else if (messageData.flow) {
       return await this.handleFlow(messageData);
     } else {
+      if (chatId && this.provider && typeof this.provider.sendTypingIndicator === 'function') {
+        const messageId = messageData.id || messageData.MessageSid || messageData.message_id;        
+        if (messageId) {
+          setTimeout(() => {
+            this.provider.sendTypingIndicator(messageId).catch(err => 
+              logger.debug('[processIncomingMessage] Typing indicator failed', { error: err.message })
+            );
+          }, 3000);
+        }
+      }
+      
       // For regular messages and media, use batching if enabled
       logger.info('Batching config:', this.batchingConfig);
       if (this.batchingConfig.enabled && chatId) {
@@ -635,17 +646,12 @@ class NexusMessaging {
    * Handle message with batching - waits for additional messages before processing
    */
   async _handleWithBatching(messageData, chatId) {
-    // Clear existing timeout if there is one
     if (this.pendingResponses.has(chatId)) {
       clearTimeout(this.pendingResponses.get(chatId));
       logger.info(`Received additional message from ${chatId}, resetting wait timer`);
     }
-    
-    // Calculate wait time with random variation
-    const waitTime = this.batchingConfig.baseWaitTime + 
-      Math.floor(Math.random() * this.batchingConfig.randomVariation);
-    
-    // Set new timeout
+
+    const waitTime = this.batchingConfig.baseWaitTime;
     const timeoutId = setTimeout(async () => {
       try {
         this.pendingResponses.delete(chatId);
@@ -659,13 +665,40 @@ class NexusMessaging {
     logger.info(`Waiting ${Math.round(waitTime/1000)} seconds for more messages from ${chatId}`);
   }
 
+  /**
+   * Start typing indicator refresh interval
+   */
+  async _startTypingRefresh(chatId) {
+    if (!this.provider || typeof this.provider.sendTypingIndicator !== 'function') {
+      return null;
+    }
+
+    const lastMessage = await Message.findOne({ 
+      numero: chatId, 
+      from_me: false,
+      message_id: { $exists: true, $ne: null }
+    }).sort({ createdAt: -1 });
+    
+    if (!lastMessage?.message_id) return null;
+    
+    return setInterval(() => 
+      this.provider.sendTypingIndicator(lastMessage.message_id).catch(err => 
+        logger.debug('[_startTypingRefresh] Failed', { error: err.message })
+      ), 20000
+    );
+  }
+
   /**
    * Process all batched messages for a chat
    */
   async _handleBatchedMessages(chatId) {
+    let typingInterval = null;
+    
     try {
       logger.info(`Processing batched messages from ${chatId} (including media if any)`);
       
+      typingInterval = await this._startTypingRefresh(chatId);
+      
       // Get assistant response
       const result = await replyAssistant(chatId);
       const botResponse = typeof result === 'string' ? result : result?.output;
@@ -685,7 +718,11 @@ class NexusMessaging {
       this.events.emit('messages:batched', { chatId, response: botResponse });
       
     } catch (error) {
-      logger.error('Error in batched message handling:', error);
+      logger.error('Error in batched message handling:', { error: error.message });
+    } finally {
+      if (typingInterval) {
+        clearInterval(typingInterval);
+      }
     }
   }
 

package/lib/helpers/messageStatusHelper.js

@@ -0,0 +1,97 @@
+const { Message } = require('../models/messageModel');
+const { logger } = require('../utils/logger');
+
+/**
+ * Update message delivery status in the database based on Twilio status callback data
+ */
+async function updateMessageStatus(messageSid, status, errorCode = null, errorMessage = null) {
+  try {
+    const statusInfo = {
+      status,
+      updatedAt: new Date()
+    };
+
+    if (errorCode) {
+      statusInfo.errorCode = errorCode;
+    }
+
+    if (errorMessage) {
+      statusInfo.errorMessage = errorMessage;
+    }
+
+    const updated = await Message.findOneAndUpdate(
+      { message_id: messageSid },
+      { $set: { statusInfo } },
+      { new: true }
+    );
+
+    if (updated) {
+      logger.info('[MessageStatus] Updated message status', {
+        messageSid,
+        status,
+        errorCode,
+        errorMessage
+      });
+    } else {
+      logger.warn('[MessageStatus] Message not found for status update', { messageSid });
+    }
+
+    return updated;
+  } catch (error) {
+    logger.error('[MessageStatus] Error updating message status', {
+      messageSid,
+      error: error.message
+    });
+    throw error;
+  }
+}
+
+/**
+ * Handle Twilio status callback webhook
+ */
+async function handleStatusCallback(twilioStatusData) {
+  const {
+    MessageSid,
+    MessageStatus,
+    ErrorCode,
+    ErrorMessage
+  } = twilioStatusData;
+
+  if (!MessageSid || !MessageStatus) {
+    logger.warn('[MessageStatus] Invalid status callback data', twilioStatusData);
+    return null;
+  }
+
+  return await updateMessageStatus(
+    MessageSid,
+    MessageStatus.toLowerCase(),
+    ErrorCode || null,
+    ErrorMessage || null
+  );
+}
+
+/**
+ * Get message status from database
+ */
+async function getMessageStatus(messageSid) {
+  try {
+    const message = await Message.findOne({ message_id: messageSid })
+      .select('statusInfo message_id numero body')
+      .lean();
+
+    return message;
+  } catch (error) {
+    logger.error('[MessageStatus] Error fetching message status from DB', {
+      messageSid,
+      error: error.message
+    });
+    return null;
+  }
+}
+
+module.exports = {
+  updateMessageStatus,
+  handleStatusCallback,
+  getMessageStatus
+};
+

package/lib/models/messageModel.js

@@ -63,6 +63,25 @@ const messageSchema = new mongoose.Schema({
   read: {
     type: Boolean,
     default: false
+  },
+  statusInfo: {
+    status: {
+      type: String,
+      enum: ['queued', 'sending', 'sent', 'delivered', 'undelivered', 'failed', 'read', null],
+      default: null
+    },
+    errorCode: {
+      type: String,
+      default: null
+    },
+    errorMessage: {
+      type: String,
+      default: null
+    },
+    updatedAt: {
+      type: Date,
+      default: null
+    }
   }
 }, { timestamps: true });
 
@@ -118,7 +137,13 @@ async function insertMessage(values) {
       clinical_context: clinical_context,
       origin: values.origin,
       tools_executed: values.tools_executed || [],
-      raw: values.raw || null
+      raw: values.raw || null,
+      statusInfo: values.statusInfo || (values.delivery_status ? {
+        status: values.delivery_status,
+        errorCode: values.delivery_error_code || null,
+        errorMessage: values.delivery_error_message || null,
+        updatedAt: values.delivery_status_updated_at || null
+      } : null)
     };
 
     await Message.findOneAndUpdate(

package/lib/routes/index.js

@@ -1,5 +1,6 @@
 // Export route definitions for customer servers to import
 // These are the route patterns without controller dependencies
+const express = require('express');
 
 const assistantRouteDefinitions = {
   'POST /active': 'activeAssistantController',
@@ -65,7 +66,6 @@ const templateRouteDefinitions = {
 
 // Helper function to create Express router from route definitions
 const createRouter = (routeDefinitions, controllers) => {
-  const express = require('express');
   const router = express.Router();
   
   for (const [route, controllerName] of Object.entries(routeDefinitions)) {

package/lib/services/assistantService.js

@@ -1,31 +1,18 @@
-const { Historial_Clinico_ID } = require('../config/airtableConfig.js');
-const AWS = require('../config/awsConfig.js');
+const { withTracing } = require('../utils/tracingDecorator.js');
 const llmConfig = require('../config/llmConfig');
-const runtimeConfig = require('../config/runtimeConfig');
 const { BaseAssistant } = require('../assistants/BaseAssistant');
-const { createProvider } = require('../providers/createProvider');
-
-const { Thread } = require('../models/threadModel.js');
-const { PredictionMetrics } = require('../models/predictionMetricsModel');
-const { insertMessage } = require('../models/messageModel');
-
-const { getCurRow } = require('../helpers/assistantHelper.js');
-const { runAssistantAndWait, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
-const { getThread, getThreadInfo } = require('../helpers/threadHelper.js');
-const { withTracing } = require('../utils/tracingDecorator.js');
-const { processThreadMessage } = require('../helpers/processHelper.js');
-const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
-const { withThreadRecovery } = require('../helpers/threadRecoveryHelper.js');
-const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
-const { logger } = require('../utils/logger');
-
-const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
+const {
+  createAssistantCore,
+  addMsgAssistantCore,
+  addInstructionCore,
+  replyAssistantCore,
+  switchAssistantCore
+} = require('./assistantServiceCore');
 
 let assistantConfig = null;
 let assistantRegistry = {};
 let customGetAssistantById = null;
 
-
 const configureAssistants = (config) => {
   if (!config) {
     throw new Error('Assistant configuration is required');
@@ -98,224 +85,46 @@ const overrideGetAssistantById = (resolverFn) => {
 
 const getAssistantById = (assistant_id, thread) => {
   if (customGetAssistantById) {
-    const inst = customGetAssistantById(assistant_id, thread);
-    if (inst) return inst;
-  }
-
-  if (!assistantConfig) {
-    assistantConfig = {};
-  }
-  
-  const AssistantClass = assistantRegistry[assistant_id];
-  if (!AssistantClass) {
-    throw new Error(`Assistant '${assistant_id}' not found. Available assistants: ${Object.keys(assistantRegistry).join(', ')}`);
+    return customGetAssistantById(assistant_id, thread);
   }
 
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const sharedClient = provider?.getClient?.() || llmConfig.openaiClient || null;
-
-  if (AssistantClass.prototype instanceof BaseAssistant) {
-    return new AssistantClass({
-      assistantId: assistant_id,
-      thread,
-      client: sharedClient,
-      provider
-    });
+  if (assistantRegistry[assistant_id]) {
+    const AssistantClass = assistantRegistry[assistant_id];
+    return new AssistantClass({ thread });
   }
 
-  try {
-    return new AssistantClass(thread);
-  } catch (error) {
-    return new AssistantClass({
-      thread,
+  if (assistantConfig && assistantConfig[assistant_id]) {
+    const config = assistantConfig[assistant_id];
+    return new BaseAssistant({
+      ...config,
       assistantId: assistant_id,
-      client: sharedClient,
-      provider
-    });
-  }
-};
-
-
-const createAssistant = async (code, assistant_id, messages=[], force=false) => {
-  const findThread = await Thread.findOne({ code: code });
-  logger.info('[createAssistant] findThread', findThread);
-  if (findThread && findThread.getConversationId() && !force) {
-    logger.info('[createAssistant] Thread already exists');
-    const updateFields = { active: true, stopped: false };
-    Thread.setAssistantId(updateFields, assistant_id);    
-    await Thread.updateOne({ code: code }, { $set: updateFields });
-    return findThread;
-  }
-
-  if (force && findThread?.getConversationId()) {
-    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    await provider.deleteConversation(findThread.getConversationId());
-    logger.info('[createAssistant] Deleted old conversation, will create new one');
-  }
-  
-  const curRow = await getCurRow(Historial_Clinico_ID, code);
-  logger.info('[createAssistant] curRow', curRow[0]);
-  const nombre = curRow?.[0]?.['name'] || null;
-  const patientId = curRow?.[0]?.['record_id'] || null;
-
-  const assistant = getAssistantById(assistant_id, null);
-  const initialThread = await assistant.create(code, curRow[0]);
-
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  for (const message of messages) {
-    await provider.addMessage({
-      threadId: initialThread.id,
-      role: 'assistant',
-      content: message
+      thread
     });
   }
-  
-  const thread = {
-    code: code,
-    patient_id: patientId,
-    nombre: nombre,
-    active: true
-  };
-  Thread.setAssistantId(thread, assistant_id);
-  Thread.setConversationId(thread, initialThread.id);
-
-  const condition = { $or: [{ code: code }] };
-  const options = { new: true, upsert: true };
-  const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
-  logger.info('[createAssistant] Updated thread:', updatedThread);
-
-  return thread;
-};
 
-const addMsgAssistant = async (code, inMessages, role = 'user', reply = false, skipSystemMessage = false) => {
-  try {
-    let thread = await Thread.findOne({ code: code });
-    logger.info(thread);
-    if (thread === null) return null;
-
-    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    
-    await withThreadRecovery(
-      async (recoveredThread = thread) => {
-        thread = recoveredThread;
-        for (const message of inMessages) {
-          logger.info(message);
-          await provider.addMessage({
-            threadId: thread.getConversationId(),
-            role: role,
-            content: message
-          });
-          
-          // Save system message to database for frontend visibility
-          // Skip if message is already saved (e.g., from getConversationReplyController)
-          if (!skipSystemMessage) {
-            try {
-              const message_id = `system_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-              await insertMessage({
-                nombre_whatsapp: 'System',
-                numero: code,
-                body: message,
-                timestamp: new Date(),
-                message_id: message_id,
-                is_group: false,
-                is_media: false,
-                from_me: true,
-                processed: true,
-                origin: 'system',
-                thread_id: thread.getConversationId(),
-                assistant_id: thread.getAssistantId(),
-                raw: { role: role }
-              });
-            } catch (err) {
-              // Don't throw - we don't want to break the flow if logging fails
-              logger.error('[addMsgAssistant] Error saving system message:', err);
-            }
-          }
-        }
-      },
-      thread,
-      process.env.VARIANT || 'assistants'
-    );
-
-    if (!reply) return null;
-
-    let output, completed;
-    let retries = 0;
-    const maxRetries = DEFAULT_MAX_RETRIES;
-    const assistant = getAssistantById(thread.getAssistantId(), thread);
-    do {
-      ({ output, completed } = await runAssistantAndWait({ thread, assistant }));
-      logger.info(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
-      
-      if (completed && output) break;
-      if (retries < maxRetries) await new Promise(resolve => setTimeout(resolve, 2000));
-      retries++;
-    } while (retries <= maxRetries && (!completed || !output));
-
-    logger.info('THE ANS IS', output);
-    return output;
-  } catch (error) {
-    logger.info(error);
-    return null;
-  }
+  throw new Error(`Assistant with ID "${assistant_id}" not found`);
 };
 
-const addInstructionCore = async (code, instruction, role = 'user') => {
-  const thread = await withTracing(getThread, 'get_thread_operation', 
-    (threadCode) => ({ 
-      'thread.code': threadCode,
-      'operation.type': 'thread_retrieval' 
-    })
-  )(code);
-  if (thread === null) return null;
-
-  const assistant = getAssistantById(thread.getAssistantId(), thread);
-  const { output, completed, retries } = await withTracing(
-    runAssistantWithRetries,
-    'run_assistant_with_retries',
-    (thread, assistant, runConfig, patientReply) => ({
-      'assistant.id': thread.getAssistantId(),
-      'assistant.max_retries': DEFAULT_MAX_RETRIES,
-      'assistant.has_patient_reply': !!patientReply
-    })
-  )(
-    thread,
-    assistant,
-    {
-      additionalInstructions: instruction,
-      additionalMessages: [
-        { role: role, content: instruction }
-      ]
-    },
-    null // no patientReply for instructions
-  );
-
-  // Save instruction to database for frontend visibility
-  try {
-    const message_id = `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-    await insertMessage({
-      nombre_whatsapp: 'Instruction',
-      numero: code,
-      body: instruction,
-      timestamp: new Date(),
-      message_id: message_id,
-      is_group: false,
-      is_media: false,
-      from_me: true,
-      processed: true,
-      origin: 'instruction',
-      thread_id: thread.getConversationId(),
-      assistant_id: thread.getAssistantId(),
-      raw: { role: role }
-    });
-  } catch (err) {
-    // Don't throw - we don't want to break the flow if logging fails
-    logger.error('[addInstructionCore] Error saving instruction message:', err);
-  }
+const createAssistant = withTracing(
+  (code, assistant_id) => createAssistantCore(code, assistant_id, getAssistantById),
+  'create_assistant',
+  (code, assistant_id) => ({
+    'assistant.thread_code': code,
+    'assistant.id': assistant_id,
+    'operation.type': 'create_assistant'
+  })
+);
 
-  logger.info('RUN RESPONSE', output);
-  return output;
-};
+const addMsgAssistant = withTracing(
+  addMsgAssistantCore,
+  'add_message_assistant',
+  (code, message, role) => ({
+    'message.thread_code': code,
+    'message.content_length': message?.length || 0,
+    'message.role': role,
+    'operation.type': 'add_message'
+  })
+);
 
 const addInsAssistant = withTracing(
   addInstructionCore,
@@ -328,199 +137,28 @@ const addInsAssistant = withTracing(
   })
 );
 
-const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}) => {
-  const timings = {};
-  const startTotal = Date.now();
-  
-  const { result: thread, duration: getThreadMs } = await withTracing(
-    getThread, 
-    'get_thread_operation', 
-    (threadCode) => ({ 
-      'thread.code': threadCode,
-      'operation.type': 'thread_retrieval',
-      'thread.provided': !!thread_
-    }),
-    { returnTiming: true }
-  )(code);
-  timings.get_thread_ms = getThreadMs;
-  
-  if (!thread_ && !thread) return null;
-  const finalThread = thread_ || thread;
-
-  const { result: patientReply, duration: getMessagesMs } = await withTracing(
-    getLastMessages,
-    'get_last_messages',
-    (code) => ({ 'thread.code': code }),
-    { returnTiming: true }
-  )(code);
-  timings.get_messages_ms = getMessagesMs;
-  
-  if (!patientReply) {
-    logger.info('[replyAssistantCore] No relevant data found for this assistant.');
-    return null;
-  }
-
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  
-  logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
-  
-  const { result: processResult, duration: processMessagesMs } = await withTracing(
-    processThreadMessage,
-    'process_thread_messages',
-    (code, patientReply, provider) => ({
-      'messages.count': patientReply.length,
-      'thread.code': code
-    }),
-    { returnTiming: true }
-  )(code, patientReply, provider);
-  
-  const { results: processResults, timings: processTimings } = processResult;
-  timings.process_messages_ms = processMessagesMs;
-  
-  logger.debug('[replyAssistantCore] Process timings breakdown', { processTimings });
-  
-  if (processTimings) {
-    timings.process_messages_breakdown = {
-      download_ms: processTimings.download_ms || 0,
-      image_analysis_ms: processTimings.image_analysis_ms || 0,
-      audio_transcription_ms: processTimings.audio_transcription_ms || 0,
-      url_generation_ms: processTimings.url_generation_ms || 0,
-      total_media_ms: processTimings.total_media_ms || 0
-    };
-  }
-  
-  const patientMsg = processResults.some(r => r.isPatient);
-  const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
-  const allMessagesToAdd = processResults.flatMap(r => r.messages || []);
-  const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
-  
-  if (allMessagesToAdd.length > 0) {
-    logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-    await withThreadRecovery(
-      async (thread = finalThread) => {
-        const threadId = thread.getConversationId();
-        await provider.addMessage({ threadId, messages: allMessagesToAdd });
-      },
-      finalThread,
-      process.env.VARIANT || 'assistants'
-    );
-  }
-  
-  await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
-  await cleanupFiles(allTempFiles);
-  
-  if (urls.length > 0) {
-    logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
-    const { result: pdfResult, duration: pdfCombinationMs } = await withTracing(
-      combineImagesToPDF,
-      'combine_images_to_pdf',
-      ({ code }) => ({
-        'pdf.thread_code': code,
-        'pdf.url_count': urls.length
-      }),
-      { returnTiming: true }
-    )({ code });
-    timings.pdf_combination_ms = pdfCombinationMs;
-    const { pdfBuffer, processedFiles } = pdfResult;
-    logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
-    
-    if (pdfBuffer) {
-      const key = `${code}-${Date.now()}-combined.pdf`;
-      const bucket = runtimeConfig.get('AWS_S3_BUCKET_NAME');
-      if (bucket) {
-        await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
-      }
-    }
-    
-    if (processedFiles && processedFiles.length) {
-      cleanupFiles(processedFiles);
-    }
-  }
-
-  if (!patientMsg || finalThread.stopped) return null;
-
-  const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
-  const { result: runResult, duration: runAssistantMs } = await withTracing(
-    runAssistantWithRetries,
-    'run_assistant_with_retries',
-    (thread, assistant, runConfig, patientReply) => ({
-      'assistant.id': thread.getAssistantId(),
-      'assistant.max_retries': DEFAULT_MAX_RETRIES,
-      'assistant.has_patient_reply': !!patientReply
-    }),
-    { returnTiming: true }
-  )(finalThread, assistant, runOptions, patientReply);
-  timings.run_assistant_ms = runAssistantMs;
-  timings.total_ms = Date.now() - startTotal;
-  
-  const { run, output, completed, retries, predictionTimeMs, tools_executed } = runResult;
-
-  logger.info('[Assistant Reply Complete]', {
-    code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-    messageCount: patientReply.length,
-    hasMedia: urls.length > 0,
-    retries,
-    totalMs: timings.total_ms,
-    toolsExecuted: tools_executed?.length || 0
-  });
-
-  if (output && predictionTimeMs) {
-    logger.debug('[replyAssistantCore] Storing metrics with timing_breakdown', { 
-      timing_breakdown: timings,
-      has_breakdown: !!timings.process_messages_breakdown
-    });
-    
-    await PredictionMetrics.create({
-      message_id: `${code}-${Date.now()}`,
-      numero: code,
-      assistant_id: finalThread.getAssistantId(),
-      thread_id: finalThread.getConversationId(),
-      prediction_time_ms: predictionTimeMs,
-      retry_count: retries,
-      completed: completed,
-      timing_breakdown: timings
-    }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
-  }
-
-  return { output, tools_executed };
-};
-
 const replyAssistant = withTracing(
-  replyAssistantCore,
+  (code, message_, thread_, runOptions) => replyAssistantCore(code, message_, thread_, runOptions, getAssistantById),
   'assistant_reply',
   (code, message_, thread_, runOptions) => ({
     'assistant.thread_code': code,
     'assistant.has_message': !!message_,
     'assistant.has_custom_thread': !!thread_,
-    'assistant.run_options': JSON.stringify(runOptions)
+    'assistant.has_run_options': !!runOptions && Object.keys(runOptions).length > 0
   })
 );
 
-const switchAssistant = async (code, assistant_id) => {
-  try {
-    const thread = await Thread.findOne({ code: code });
-    logger.info('Inside thread', thread);
-    if (thread === null) return;
-
-    const variant = process.env.VARIANT || 'assistants';
-    const updateFields = { active: true, stopped: false };
-    
-    if (variant === 'responses') {
-      updateFields.prompt_id = assistant_id;
-    } else {
-      updateFields.assistant_id = assistant_id;
-    }
-
-    await Thread.updateOne({ code }, { $set: updateFields });  
-  } catch (error) {
-    logger.info(error);
-    return null;
-  }
-};
+const switchAssistant = withTracing(
+  switchAssistantCore,
+  'switch_assistant',
+  (code, assistant_id) => ({
+    'assistant.thread_code': code,
+    'assistant.new_id': assistant_id,
+    'operation.type': 'switch_assistant'
+  })
+);
 
 module.exports = {
-  getThread,
-  getThreadInfo,
   getAssistantById,
   createAssistant,
   replyAssistant,
@@ -529,6 +167,5 @@ module.exports = {
   switchAssistant,
   configureAssistants,
   registerAssistant,
-  overrideGetAssistantById,
-  runAssistantAndWait
+  overrideGetAssistantById
 };

package/lib/services/assistantServiceCore.js

@@ -0,0 +1,215 @@
+const AWS = require('../config/awsConfig.js');
+const runtimeConfig = require('../config/runtimeConfig');
+const { createProvider } = require('../providers/createProvider');
+
+const { Thread } = require('../models/threadModel.js');
+const { PredictionMetrics } = require('../models/predictionMetricsModel');
+const { insertMessage } = require('../models/messageModel');
+
+const { getCurRow, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
+const { getThread } = require('../helpers/threadHelper.js');
+const { processThreadMessage } = require('../helpers/processHelper.js');
+const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
+const { withThreadRecovery } = require('../helpers/threadRecoveryHelper.js');
+const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
+const { logger } = require('../utils/logger');
+
+const createAssistantCore = async (code, assistant_id, getAssistantById) => {
+  const thread = await getThread(code);
+  if (!thread) return null;
+
+  const assistant = getAssistantById(assistant_id, thread);
+  const curRow = await getCurRow(code);
+  const context = { curRow };
+
+  try {
+    await assistant.create(code, context);
+    return { success: true, assistant_id };
+  } catch (error) {
+    logger.error('[createAssistantCore] Error:', error);
+    return { success: false, error: error.message };
+  }
+};
+
+const addMsgAssistantCore = async (code, message, role = 'user') => {
+  const thread = await getThread(code);
+  if (!thread) return null;
+
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+  const threadId = thread.getConversationId();
+
+  try {
+    await provider.addMessage({ threadId, messages: [{ role, content: message }] });
+    await insertMessage({ code, message, role });
+    return { success: true };
+  } catch (error) {
+    logger.error('[addMsgAssistantCore] Error:', error);
+    return { success: false, error: error.message };
+  }
+};
+
+const addInstructionCore = async (code, instruction, role = 'user') => {
+  const thread = await getThread(code);
+  if (!thread) return null;
+
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+  const threadId = thread.getConversationId();
+
+  try {
+    await provider.addMessage({ threadId, messages: [{ role, content: instruction }] });
+    return { success: true };
+  } catch (error) {
+    logger.error('[addInstructionCore] Error:', error);
+    return { success: false, error: error.message };
+  }
+};
+
+const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}, getAssistantById) => {
+  const timings = {};
+  const startTotal = Date.now();
+  
+  try {
+    const thread = thread_ || await getThread(code);
+    timings.get_thread_ms = 0;
+    
+    if (!thread) return null;
+    const finalThread = thread;
+
+    const patientReply = await getLastMessages(code);
+    timings.get_messages_ms = 0;
+    
+    if (!patientReply) {
+      logger.info('[replyAssistantCore] No relevant data found for this assistant.');
+      return null;
+    }
+
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+    const processResult = await processThreadMessage(code, patientReply, provider);
+    
+    const { results: processResults, timings: processTimings } = processResult;
+    timings.process_messages_ms = 0;
+    
+    logger.debug('[replyAssistantCore] Process timings breakdown', { processTimings });
+
+    if (processTimings) {
+      timings.process_messages_breakdown = {
+        download_ms: processTimings.download_ms || 0,
+        image_analysis_ms: processTimings.image_analysis_ms || 0,
+        audio_transcription_ms: processTimings.audio_transcription_ms || 0,
+        url_generation_ms: processTimings.url_generation_ms || 0,
+        total_media_ms: processTimings.total_media_ms || 0
+      };
+    }
+
+    const patientMsg = processResults.some(r => r.isPatient);
+    const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
+    const allMessagesToAdd = processResults.flatMap(r => r.messages || []);
+    const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
+    
+    if (allMessagesToAdd.length > 0) {
+      logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
+      await withThreadRecovery(
+        async (thread = finalThread) => {
+          const threadId = thread.getConversationId();
+          await provider.addMessage({ threadId, messages: allMessagesToAdd });
+        },
+        finalThread,
+        process.env.VARIANT || 'assistants'
+      );
+    }
+
+    await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
+    await cleanupFiles(allTempFiles);
+
+    if (urls.length > 0) {
+      logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+      const pdfResult = await combineImagesToPDF({ code });
+      timings.pdf_combination_ms = 0;
+      const { pdfBuffer, processedFiles } = pdfResult;
+      logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+      
+      if (pdfBuffer) {
+        const key = `${code}-${Date.now()}-combined.pdf`;
+        const bucket = runtimeConfig.get('AWS_S3_BUCKET_NAME');
+        if (bucket) {
+          await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
+        }
+      }
+      
+      if (processedFiles && processedFiles.length) {
+        cleanupFiles(processedFiles);
+      }
+    }
+
+    if (!patientMsg || finalThread.stopped) return null;
+
+    const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
+    const runResult = await runAssistantWithRetries(finalThread, assistant, runOptions, patientReply);
+    timings.run_assistant_ms = 0;
+    timings.total_ms = Date.now() - startTotal;
+    
+    const { run, output, completed, retries, predictionTimeMs, tools_executed } = runResult;
+
+    logger.info('[Assistant Reply Complete]', {
+      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+      messageCount: patientReply.length,
+      hasMedia: urls.length > 0,
+      retries,
+      totalMs: timings.total_ms,
+      toolsExecuted: tools_executed?.length || 0
+    });
+
+    if (output && predictionTimeMs) {
+      logger.debug('[replyAssistantCore] Storing metrics with timing_breakdown', { 
+        timing_breakdown: timings,
+        has_breakdown: !!timings.process_messages_breakdown
+      });
+      
+      await PredictionMetrics.create({
+        message_id: `${code}-${Date.now()}`,
+        numero: code,
+        assistant_id: finalThread.getAssistantId(),
+        thread_id: finalThread.getConversationId(),
+        prediction_time_ms: predictionTimeMs,
+        retry_count: retries,
+        completed: completed,
+        timing_breakdown: timings
+      }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
+    }
+
+    return { output, tools_executed };
+  } catch (error) {
+    logger.error('[replyAssistantCore] Error:', { error: error.message });
+    throw error;
+  }
+};
+
+const switchAssistantCore = async (code, assistant_id) => {
+  try {
+    const thread = await Thread.findOne({ code });
+    if (!thread) {
+      return null;
+    }
+
+    const updateFields = {
+      assistant_id,
+      stopped: false,
+      updatedAt: new Date()
+    };
+
+    await Thread.updateOne({ code }, { $set: updateFields });
+    return { success: true, assistant_id };
+  } catch (error) {
+    logger.info(error);
+    return null;
+  }
+};
+
+module.exports = {
+  createAssistantCore,
+  addMsgAssistantCore,
+  addInstructionCore,
+  replyAssistantCore,
+  switchAssistantCore
+};

package/lib/services/twilioService.js

@@ -49,6 +49,11 @@ const TwilioService = {
     return await nexusProvider.createTemplate(templateData);
   },
 
+  async getMessageStatus(messageSid) {
+    checkTwilioSupport();
+    return await nexusProvider.getMessageStatus(messageSid);
+  },
+
   // Add any other Twilio operations as needed
   configureNexusProvider
 };

package/lib/storage/MongoStorage.js

@@ -187,7 +187,13 @@ class MongoStorage {
       template_variables: messageData.variables ? JSON.stringify(messageData.variables) : null,
       raw: messageData.raw || null,
       origin,
-      tools_executed: messageData.tools_executed || []
+      tools_executed: messageData.tools_executed || [],
+      statusInfo: messageData.statusInfo || (messageData.delivery_status ? {
+        status: messageData.delivery_status,
+        errorCode: messageData.delivery_error_code || null,
+        errorMessage: messageData.delivery_error_message || null,
+        updatedAt: messageData.delivery_status_updated_at || null
+      } : null)
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.4.13",
+  "version": "2.5.1-fix",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",