@peopl-health/nexus 2.6.0 → 2.7.0

package/examples/basic-usage.js

@@ -66,13 +66,12 @@ class GeneralAssistant extends BaseAssistant {
 }
 
 async function startServer() {
-  // Initialize Nexus with all services and batching enabled
+  // Initialize Nexus with check-after processing (immediate response, checks for new messages after)
   const nexus = new Nexus({
     messaging: {
       messageBatching: {
-        enabled: true,
-        baseWaitTime: 10000,    // 10 seconds base wait (shorter for testing)
-        randomVariation: 5000   // 0-5 seconds random variation
+        enabled: true,           // Enable check-after processing
+        checkDelayMs: 100        // Delay before checking for new messages (ms)
       }
     }
   });

package/lib/assistants/BaseAssistant.js

@@ -170,22 +170,7 @@ class BaseAssistant {
   async create(code, context = {}) {
     this._ensureClient();
     this.status = 'active';
-
-    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 conversation = await provider.createConversation({
-      messages: initialMessages,
-    });
-
-    this.thread = {
-      ...conversation,
-      thread_id: conversation?.id,
-      code,
-    };
+    this.thread = { code };
 
     return this.thread;
   }

package/lib/config/airtableConfig.js

@@ -13,6 +13,7 @@ const Logging_ID = require('./runtimeConfig').get('AIRTABLE_LOGGING_ID') || 'app
 const Monitoreo_ID = require('./runtimeConfig').get('AIRTABLE_MONITOREO_ID') || 'appdvraKSdp0XVn5n';
 const Programa_Juntas_ID = require('./runtimeConfig').get('AIRTABLE_PROGRAMA_JUNTAS_ID') || 'appKFWzkcDEWlrXBE';
 const Symptoms_ID = require('./runtimeConfig').get('AIRTABLE_SYMPTOMS_ID') || 'appQRhZlQ9tMfYZWJ';
+const Follow_Up_ID = require('./runtimeConfig').get('AIRTABLE_FOLLOW_UP_ID') || 'appBjKw1Ub0KkbZf0';
 const Webinars_Leads_ID = require('./runtimeConfig').get('AIRTABLE_WEBINARS_LEADS_ID') || 'appzjpVXTI0TgqGPq';
 const Product_ID = require('./runtimeConfig').get('AIRTABLE_PRODUCT_ID') || 'appu2YDW2pKDYLL5H';
 
@@ -30,6 +31,7 @@ const BASE_MAP = {
   monitoreo: Monitoreo_ID,
   programa: Programa_Juntas_ID,
   symptoms: Symptoms_ID,
+  followup: Follow_Up_ID,
   webinars: Webinars_Leads_ID,
   product: Product_ID
 };
@@ -44,6 +46,7 @@ module.exports = {
   Monitoreo_ID,
   Programa_Juntas_ID,
   Symptoms_ID,
+  Follow_Up_ID,
   Webinars_Leads_ID,
   Product_ID,
   // Helper function to get base by ID

package/lib/controllers/conversationController.js

@@ -13,7 +13,7 @@ const Message = mongoose.models.Message;
 
 const getConversationController = async (req, res) => {
   const startTime = Date.now();
-  logger.info('Starting getConversationController at', { time: new Date().toISOString() });
+  logger.info(`Starting getConversationController at ${new Date().toISOString()}`);
 
   try {
     // Parse pagination parameters
@@ -34,7 +34,7 @@ const getConversationController = async (req, res) => {
     }
     
     const messageCount = await Message.countDocuments({});
-    logger.info('Total message count:', { messageCount });
+    logger.info(`Total message count: ${messageCount}`);
     
     if (messageCount === 0) {
       logger.info('No messages found in database, returning empty conversations list');
@@ -63,7 +63,7 @@ const getConversationController = async (req, res) => {
     const totalPages = Math.ceil(total / limit);
     const totalTime = Date.now() - startTime;
     
-    logger.info('Number of conversations found:', { conversationsCount: conversations?.length || 0 });
+    logger.info(`Number of conversations found: ${conversations?.length || 0}`);
     logger.info(`Total controller execution time: ${totalTime}ms`);
     logger.info(`Filter: ${filter}, Pagination: ${conversations.length} of ${total} conversations (page ${page}/${totalPages})`);
 
@@ -84,7 +84,7 @@ const getConversationController = async (req, res) => {
 
   } catch (error) {
     logger.error('Error fetching conversations:', { error });
-    logger.error('Error stack:', { error: error.stack });
+    logger.error('Error stack:', { stack: error.stack });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversations'
@@ -93,10 +93,10 @@ const getConversationController = async (req, res) => {
 };
 
 const getConversationMessagesController = async (req, res) => {
-  logger.info('Starting getConversationMessagesController at', { time: new Date().toISOString() });
+  logger.info(`Starting getConversationMessagesController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber } = req.params;
-    logger.info('Requested conversation for phone number:', { phoneNumber });
+    logger.info(`Requested conversation for phone number: ${phoneNumber}`);
     
     if (!phoneNumber) {
       return res.status(400).json({
@@ -113,13 +113,12 @@ const getConversationMessagesController = async (req, res) => {
       try {
         query.createdAt = { $lt: new Date(before) };
       } catch (parseError) {
-        logger.warn('Invalid date format for before parameter:', { before, parseError });
+        logger.warn(`Invalid date format for before parameter: ${before}`, { parseError });
         query.createdAt = { $lt: before };
       }
     }
     
-    logger.info('Fetching conversation messages', { query, limit });
-    logger.info('Executing Message.find', { query });
+    logger.info(`Fetching conversation messages ${query}, limit ${limit}`);
     let messages = [];
     
     try {
@@ -136,18 +135,18 @@ const getConversationMessagesController = async (req, res) => {
         
         const problematicMessages = messages.filter(msg => {
           if (!msg || !msg.numero || !msg.createdAt) {
-            logger.warn('Found message missing required fields:', msg?._id || 'unknown');
+            logger.warn(`Found message missing required fields: ${msg?._id || 'unknown'}`);
             return true;
           }
           
           if (msg.media) {
             if (!msg.media || typeof msg.media !== 'object') {
-              logger.warn('Found media message with invalid media data:', { msgId: msg._id });
+              logger.warn(`Found media message with invalid media data: ${msg._id}`);
               return true;
             }
             
             if (msg.media && (typeof msg.media.data === 'function' || msg.media.data instanceof Buffer)) {
-              logger.warn('Found media message with Buffer data that might cause serialization issues:', { msgId: msg._id });
+              logger.warn(`Found media message with Buffer data that might cause serialization issues: ${msg._id}`);
               return true;
             }
           }
@@ -157,12 +156,13 @@ const getConversationMessagesController = async (req, res) => {
         
         if (problematicMessages.length > 0) {
           logger.warn(`Found ${problematicMessages.length} potentially problematic messages`);
-          logger.info('First problematic message IDs:', problematicMessages.slice(0, 3).map(m => m?._id || 'unknown'));
+          logger.info(`First problematic message IDs: ${problematicMessages.slice(0, 3).map(m => m?._id || 'unknown')}`);
         }
       } else {
         logger.info('No messages found for this query');
       }
     } catch (err) {
+      logger.error('Database query error in message retrieval:', { err });
       logger.error('Database query error in message retrieval:', { err });
       messages = [];
     }
@@ -174,7 +174,7 @@ const getConversationMessagesController = async (req, res) => {
         JSON.stringify(msg);
         return msg;
       } catch (serializationError) {
-        logger.error(`Found non-serializable message with ID ${msg._id}:`, { serializationError });
+        logger.error(`Found non-serializable message with ID ${msg._id}:`, { serializationError}) ;
         return {
           _id: msg._id?.toString() || 'unknown',
           numero: msg.numero || phoneNumber,
@@ -197,6 +197,7 @@ const getConversationMessagesController = async (req, res) => {
     });
     logger.info('Successfully sent conversation messages response');
   } catch (error) {
+    logger.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, { error });
     logger.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, { error });
     res.status(500).json({
       success: false,
@@ -206,7 +207,7 @@ const getConversationMessagesController = async (req, res) => {
 };
 
 const getConversationReplyController = async (req, res) => {
-  logger.info('Starting getConversationReplyController at', { time: new Date().toISOString() });
+  logger.info(`Starting getConversationReplyController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber, message, mediaData, contentSid, variables } = req.body;
     logger.info('Reply request params:', { 
@@ -225,7 +226,7 @@ const getConversationReplyController = async (req, res) => {
     }
         
     const formattedPhoneNumber = ensureWhatsAppFormat(phoneNumber);
-    logger.info('Formatted phone number:', { formattedPhoneNumber });
+    logger.info(`Formatted phone number: ${formattedPhoneNumber}`);
     
     const messageData = {
       code: formattedPhoneNumber,
@@ -235,7 +236,7 @@ const getConversationReplyController = async (req, res) => {
     
     // Handle template message (contentSid provided)
     if (contentSid) {
-      logger.info('Processing template message with contentSid:', { contentSid });
+      logger.info(`Processing template message with contentSid: ${contentSid}`);
       messageData.contentSid = contentSid;
       
       if (variables && Object.keys(variables).length > 0) {
@@ -281,10 +282,12 @@ const getConversationReplyController = async (req, res) => {
       message: 'Reply sent successfully'
     });
   } catch (error) {
+    logger.error('Error sending reply:', { error });
     logger.error('Error sending reply:', { error });
     logger.info('Request body', { body: req.body || {} });
     const errorMsg = error.message || 'Failed to send reply';
     logger.error('Responding with error:', { errorMsg });
+    logger.error('Responding with error:', { errorMsg });
     res.status(500).json({
       success: false,
       error: errorMsg
@@ -361,6 +364,7 @@ const searchConversationsController = async (req, res) => {
             batch.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
             ')';
           return getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula).catch(error => {
+            logger.error('Error fetching Airtable batch for search:', { error });
             logger.error('Error fetching Airtable batch for search:', { error });
             return [];
           });
@@ -381,6 +385,7 @@ const searchConversationsController = async (req, res) => {
         logger.info(`Found ${Object.keys(airtableNameMap).length} names in Airtable for search results (${batches.length} batches)`);
       } catch (error) {
         logger.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', { error });
+        logger.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', { error });
       }
     }
 
@@ -445,6 +450,7 @@ const searchConversationsController = async (req, res) => {
     });
 
   } catch (error) {
+    logger.error('Error searching conversations:', { error });
     logger.error('Error searching conversations:', { error });
     res.status(500).json({
       success: false,
@@ -478,6 +484,7 @@ const getConversationsByNameController = async (req, res) => {
       }))
     });
   } catch (error) {
+    logger.error('Error fetching conversations by name:', { error });
     logger.error('Error fetching conversations by name:', { error });
     res.status(500).json({
       success: false,
@@ -524,6 +531,7 @@ const getNewMessagesController = async (req, res) => {
       messages: messages
     });
   } catch (error) {
+    logger.error(`Error fetching new messages for ${req.params.phoneNumber}:`, { error });
     logger.error(`Error fetching new messages for ${req.params.phoneNumber}:`, { error });
     res.status(500).json({
       success: false,
@@ -533,7 +541,7 @@ const getNewMessagesController = async (req, res) => {
 };
 
 const markMessagesAsReadController = async (req, res) => {
-  logger.info('Starting markMessagesAsReadController at', { time: new Date().toISOString() });
+  logger.info(`Starting markMessagesAsReadController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber } = req.params;
         
@@ -544,7 +552,7 @@ const markMessagesAsReadController = async (req, res) => {
       });
     }
         
-    logger.info('Marking messages as read for phone number:', { phoneNumber });
+    logger.info(`Marking messages as read for phone number: ${phoneNumber}`);
     const result = await Message.updateMany(
       { 
         numero: phoneNumber, 
@@ -564,7 +572,7 @@ const markMessagesAsReadController = async (req, res) => {
     });
   } catch (error) {
     logger.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, { error });
-    logger.error('Error stack:', { error: error.stack });
+    logger.error('Error stack:', { errorStack: error.stack });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to mark messages as read'
@@ -573,7 +581,7 @@ const markMessagesAsReadController = async (req, res) => {
 };
 
 const sendTemplateToNewNumberController = async (req, res) => {
-  logger.info('Starting sendTemplateToNewNumberController at', { time: new Date().toISOString() });
+  logger.info(`Starting sendTemplateToNewNumberController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber, templateId, variables } = req.body;
     
@@ -618,6 +626,7 @@ const sendTemplateToNewNumberController = async (req, res) => {
       messageId: message.sid
     });
   } catch (error) {
+    logger.error('Error sending template to new number:', { error });
     logger.error('Error sending template to new number:', { error });
     res.status(500).json({
       success: false,
@@ -627,14 +636,14 @@ const sendTemplateToNewNumberController = async (req, res) => {
 };
 
 const getOpenAIThreadMessagesController = async (req, res) => {
-  logger.info('Starting getOpenAIThreadMessagesController at', { time: new Date().toISOString() });
+  logger.info(`Starting getOpenAIThreadMessagesController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber } = req.params;
     const { limit = 50, order = 'desc', runId } = req.query;
     const variant = process.env.VARIANT || 'assistants';
     
-    logger.info('Fetching OpenAI thread messages for:', { phoneNumber });
-    logger.info('Variant:', { variant }, 'Limit:', { limit }, 'Order:', { order });
+    logger.info(`Fetching OpenAI thread messages for: ${phoneNumber}`);
+    logger.info(`Variant: ${variant}, Limit: ${limit}, Order: ${order}`);
     
     if (!phoneNumber) {
       return res.status(400).json({
@@ -649,7 +658,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     }).sort({ createdAt: -1 });
     
     if (!thread) {
-      logger.info('No active OpenAI thread found for:', { phoneNumber });
+      logger.info(`No active OpenAI thread found for: ${phoneNumber}`);
       return res.status(404).json({
         success: false,
         error: 'No active OpenAI thread found for this phone number'
@@ -657,14 +666,14 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     }
     
     let conversationId = thread.conversation_id;
-    logger.info('Thread found - Conversation ID:', { conversationId });
+    logger.info(`Thread found - Conversation ID: ${conversationId}`);
     
     const provider = llmConfig.getOpenAIProvider({ instantiate: true, variant });
     if (!provider) {
       throw new Error('OpenAI provider not initialized');
     }
     
-    logger.info('Using provider variant:', { variant: provider.getVariant() });
+    logger.info(`Using provider variant: ${provider.getVariant()}`);
     
     const queryParams = { 
       threadId: conversationId, 
@@ -679,6 +688,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     let messages;
     let threadRecreated = false;
     
+    logger.info('Calling listMessages with params:', { queryParams });
     logger.info('Calling listMessages with params:', { queryParams });
     messages = await withThreadRecovery(
       async (currentThread = thread) => {
@@ -713,7 +723,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     
   } catch (error) {
     logger.error('Error fetching OpenAI thread messages:', { error });
-    logger.error('Error stack:', { error: error.stack });
+    logger.error('Error stack:', { errorStack: error.stack });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch OpenAI thread messages'

package/lib/core/NexusMessaging.js

@@ -41,11 +41,11 @@ class NexusMessaging {
       keyword: [],
       flow: []
     };
-    // Message batching
-    this.pendingResponses = new Map();
+    // Message processing with check-after strategy
+    this.processingLocks = new Map(); // Per-chat locks to prevent parallel processing
     this.batchingConfig = {
-      enabled: config.messageBatching?.enabled ?? false,
-      baseWaitTime: config.messageBatching?.baseWaitTime ?? 10000
+      enabled: config.messageBatching?.enabled ?? true, // Enabled by default with check-after
+      checkDelayMs: config.messageBatching?.checkDelayMs ?? 100 // Delay before checking for new messages
     };
   }
 
@@ -393,10 +393,9 @@ class NexusMessaging {
     } else if (messageData.flow) {
       return await this.handleFlow(messageData);
     } else {
-      // For regular messages and media, use batching if enabled
-      logger.info('Batching config:', this.batchingConfig);
+      // For regular messages and media, use check-after processing
       if (this.batchingConfig.enabled && chatId) {
-        return await this._handleWithBatching(messageData, chatId);
+        return await this._handleWithCheckAfter(chatId);
       } else {
         if (messageData.media) {
           return await this.handleMedia(messageData);
@@ -649,77 +648,52 @@ class NexusMessaging {
   }
 
   /**
-   * Handle message with batching - waits for additional messages before processing
+   * Handle message with check-after strategy - process immediately, check for new messages after
    */
-  async _handleWithBatching(messageData, chatId) {
-    const existing = this.pendingResponses.get(chatId);
-    if (existing) {
-      clearTimeout(existing.timeoutId);
-      if (existing.typingInterval) {
-        clearInterval(existing.typingInterval);
-      }
-      logger.info(`Received additional message from ${chatId}, resetting wait timer`);
-    }
-
-    // Start typing indicator refresh for batching period
-    const typingInterval = await this._startTypingRefresh(chatId);
-
-    const waitTime = this.batchingConfig.baseWaitTime;
-    const timeoutId = setTimeout(async () => {
-      try {
-        if (typingInterval) {
-          clearInterval(typingInterval);
-        }
-        this.pendingResponses.delete(chatId);
-        await this._handleBatchedMessages(chatId);
-      } catch (error) {
-        logger.error(`Error handling batched messages for ${chatId}:`, error);
-      }
-    }, waitTime);
-    
-    this.pendingResponses.set(chatId, { timeoutId, typingInterval });
-    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;
+  async _handleWithCheckAfter(chatId) {
+    // If already processing this chat, just return (message is saved, will be picked up)
+    if (this.processingLocks.has(chatId)) {
+      logger.info(`[CheckAfter] Already processing ${chatId}, new message will be included`);
+      return;
     }
 
-    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 })
-      ), 5000
-    );
+    await this._processWithLock(chatId);
   }
 
   /**
-   * Process all batched messages for a chat
+   * Process messages with per-chat lock and check-after logic
    */
-  async _handleBatchedMessages(chatId) {
+  async _processWithLock(chatId) {
+    this.processingLocks.set(chatId, true);
     let typingInterval = null;
-    
+
     try {
-      logger.info(`Processing batched messages from ${chatId} (including media if any)`);
-      
       typingInterval = await this._startTypingRefresh(chatId);
-      
-      // Get assistant response
+      logger.info(`[CheckAfter] Processing messages for ${chatId}`);
+
+      // Process with assistant
       const result = await replyAssistant(chatId);
       const botResponse = typeof result === 'string' ? result : result?.output;
       const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
-      
+
+      // Small delay to catch very recent DB writes
+      await new Promise(resolve => setTimeout(resolve, this.batchingConfig.checkDelayMs));
+
+      // Check for new unprocessed messages
+      const hasNewMessages = await Message.exists({
+        numero: chatId,
+        processed: false,
+        from_me: false
+      });
+
+      if (hasNewMessages) {
+        logger.info(`[CheckAfter] New messages detected for ${chatId}, discarding response and reprocessing`);
+        if (typingInterval) clearInterval(typingInterval);
+        // Recursively process with new messages
+        return await this._processWithLock(chatId);
+      }
+
+      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -729,40 +703,45 @@ class NexusMessaging {
           tools_executed
         });
       }
-      
-      // Emit event for batched processing
-      this.events.emit('messages:batched', { chatId, response: botResponse });
-      
+
+      this.events.emit('messages:processed', { chatId, response: botResponse });
+
     } catch (error) {
-      logger.error('Error in batched message handling:', { error: error.message });
+      logger.error('[CheckAfter] Error processing messages:', { chatId, error: error.message });
     } finally {
-      if (typingInterval) {
-        clearInterval(typingInterval);
-      }
+      if (typingInterval) clearInterval(typingInterval);
+      this.processingLocks.delete(chatId);
     }
   }
 
   /**
-   * Clear pending response for a chat (useful for cleanup)
+   * Start typing indicator refresh interval
    */
-  clearPendingResponse(chatId) {
-    const pending = this.pendingResponses.get(chatId);
-    if (pending) {
-      if (pending.timeoutId) {
-        clearTimeout(pending.timeoutId);
-      }
-      if (pending.typingInterval) {
-        clearInterval(pending.typingInterval);
-      }
-      this.pendingResponses.delete(chatId);
+  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 })
+      ), 5000
+    );
   }
 
   /**
-   * Get batching status for a chat
+   * Check if chat is currently being processed
    */
-  hasPendingResponse(chatId) {
-    return this.pendingResponses.has(chatId);
+  isProcessing(chatId) {
+    return this.processingLocks.has(chatId);
   }
 }
 

package/lib/helpers/messageHelper.js

@@ -2,31 +2,6 @@ const moment = require('moment-timezone');
 const { Message } = require('../models/messageModel.js');
 const { logger } = require('../utils/logger');
 
-const addMessageToThread = async (reply, messagesChat, provider, thread) => {
-  const threadId = thread.getConversationId();
-  
-  if (reply.interactive_type === 'flow') {
-    logger.info(`[addMessageToThread] Skipping flow message (UI only) - ID: ${reply.message_id}`);
-    return;
-  }
-  
-  if (reply.origin === 'whatsapp_platform') {
-    await provider.addMessage({
-      threadId,
-      role: 'assistant',
-      content: messagesChat
-    });
-  } else if (reply.origin === 'patient') {
-    await provider.addMessage({
-      threadId,
-      role: 'user',
-      content: messagesChat
-    });
-  }
-  
-  logger.info(`[addMessageToThread] Message added - ID: ${reply.message_id}, Thread: ${threadId}, Origin: ${reply.origin}`);
-};
-
 const updateMessageRecord = async (reply, thread) => {
   const threadId = thread.getConversationId();
   
@@ -125,7 +100,6 @@ async function isRecentMessage(chatId) {
 }
 
 module.exports = {
-  addMessageToThread,
   updateMessageRecord,
   getLastMessages,
   getLastNMessages,

package/lib/models/messageModel.js

@@ -80,6 +80,12 @@ messageSchema.index({ numero: 1, createdAt: -1 });
 messageSchema.index({ numero: 1, processed: 1, origin: 1 }, { name: 'numero_processed_origin_idx' });
 messageSchema.index({ numero: 1, createdAt: -1, processed: 1 }, { name: 'numero_created_processed_idx' });
 
+// Indexes for conversation aggregation queries
+messageSchema.index({ group_id: 1, createdAt: 1 }, { name: 'conversation_sort_idx' });
+messageSchema.index({ group_id: 1, from_me: 1, read: 1 }, { name: 'unread_filter_idx' });
+messageSchema.index({ group_id: 1, numero: 1, createdAt: -1 }, { name: 'conversation_lookup_idx' });
+messageSchema.index({ createdAt: -1 }, { name: 'global_sort_idx' });
+
 messageSchema.pre('save', function (next) {
   if (this.timestamp) {
     this.timestamp = moment.tz(this.timestamp, 'America/Mexico_City').toDate();

package/lib/providers/OpenAIResponsesProvider.js

@@ -3,9 +3,8 @@ const { Thread } = require('../models/threadModel');
 const { retryWithBackoff } = require('../utils/retryHelper');
 const {
   handleFunctionCalls: handleFunctionCallsUtil,
-  handlePendingFunctionCalls: handlePendingFunctionCallsUtil,
-  transformToolsForResponsesAPI: transformToolsForResponsesAPIUtil
 } = require('./OpenAIResponsesProviderTools');
+const { DefaultConversationManager } = require('../services/DefaultConversationManager');
 const { logger } = require('../utils/logger');
 
 const CONVERSATION_PREFIX = 'conv_';
@@ -25,6 +24,7 @@ class OpenAIResponsesProvider {
       organization,
       client,
       defaultModels = {},
+      conversationManager,
     } = options;
 
     if (!client && !apiKey) {
@@ -41,6 +41,7 @@ class OpenAIResponsesProvider {
     };
 
     this.variant = 'responses';
+    this.conversationManager = conversationManager || new DefaultConversationManager();
 
     this.responses = this.client.responses;
     this.conversations = this.client.conversations;
@@ -161,33 +162,6 @@ class OpenAIResponsesProvider {
     return await this.client.conversations.items.list(id, { order, limit });
   }
 
-  async cleanupOrphanedFunctionCalls(threadId, deleteAll = false) {
-    try {
-      const id = this._ensurethreadId(threadId);
-      const messages = await this.listMessages({ threadId: id, order: 'desc' });
-      const items = messages?.data || [];
-      
-      if (items.length === 0) return;
-
-      if (deleteAll) {
-        logger.info(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
-        await Promise.all(items.map(item => 
-          this.conversations.items.delete(item.id, {conversation_id: id})
-        ));
-        return;
-      }
-
-      const outputCallIds = new Set(items.filter(i => i.type === 'function_call_output').map(o => o.call_id));
-      const orphanedCalls = items.filter(i => i.type === 'function_call' && !outputCallIds.has(i.call_id));
-      
-      if (orphanedCalls.length > 0) {
-        await Promise.all(orphanedCalls.map(call => this.conversations.items.delete(call.id, {conversation_id: id})));
-      }
-    } catch (error) {
-      logger.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
-    }
-  }
-
   _normalizeThread(thread) {
     return {
       conversationId: thread.conversation_id || thread.getConversationId?.(),
@@ -200,107 +174,138 @@ class OpenAIResponsesProvider {
    */
   async executeRun({ thread, assistant, tools = [], config = {} }) {
     const { conversationId, assistantId } = this._normalizeThread(thread);
-    const preparedConfig = {
-      ...config,
-      assistant,
-      toolMetadata: {
-        numero: thread.code,
-        assistant_id: assistantId
-      }
-    };
-
+    
     logger.info('[OpenAIResponsesProvider] Starting run', {
       conversationId,
       assistantId
     });
 
-    const filter = thread.code ? { code: thread.code, active: true } : null;
-    const result = await this.runConversation({
-      threadId: conversationId,
-      assistantId,
-      tools,
-      ...preparedConfig
-    });
-
-    const completed = result.status === 'completed';
-    const output = await this.getRunText({ 
-      runId: result.id, 
-      fallback: '' 
-    });
+    try {
+      // Delegate context building to conversation manager
+      const context = await this.conversationManager.buildContext({
+        thread,
+        assistant,
+        config: {
+          ...config,
+          threadId: conversationId,
+          assistantId,
+          toolMetadata: {
+            numero: thread.code,
+            assistant_id: assistantId
+          }
+        }
+      });
 
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: null } });
-    }
+      const filter = thread.code ? { code: thread.code, active: true } : null;
+      
+      // Get clinical context for prompt variables
+      const clinicalData = await this.conversationManager.getClinicalData(thread.code);
+      const promptVariables = clinicalData ? {
+        clinical_context: clinicalData.clinicalContext || '',
+        last_symptoms: clinicalData.lastSymptoms || ''
+      } : null;
+
+      // Execute with built context
+      const result = await this.runConversation({
+        threadId: conversationId,
+        assistantId,
+        tools,
+        context,
+        promptVariables,
+        assistant,
+        ...config
+      });
+
+      // Delegate response processing to conversation manager
+      await this.conversationManager.processResponse(result, thread, config);
+
+      const completed = result.status === 'completed';
+      const output = await this.getRunText({ 
+        runId: result.id, 
+        fallback: '' 
+      });
+
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: null } });
+      }
 
-    logger.info('[OpenAIResponsesProvider] Run complete', {
-      runId: result.id,
-      completed,
-      toolsExecuted: result.tools_executed?.length || 0
-    });
+      logger.info('[OpenAIResponsesProvider] Run complete', {
+        runId: result.id,
+        completed,
+        toolsExecuted: result.tools_executed?.length || 0
+      });
 
-    return {
-      run: result,
-      completed,
-      output,
-      tools_executed: result.tools_executed || [],
-      retries: result.retries || 0
-    };
+      return {
+        run: result,
+        completed,
+        output,
+        tools_executed: result.tools_executed || [],
+        retries: result.retries || 0
+      };
+      
+    } catch (error) {
+      logger.error('[OpenAIResponsesProvider] Execute run failed', {
+        conversationId,
+        assistantId,
+        error: error.message
+      });
+      throw error;
+    }
   }
 
   async runConversation({
     threadId,
     assistantId,
     additionalMessages = [],
+    context = null,
     instructions = null,
     additionalInstructions = null,
-    toolOutputs = [],
     metadata = {},
     topP,
     temperature,
     maxOutputTokens,
     truncationStrategy = 'auto',
-    tools = [],
     model,
     assistant,
     toolMetadata,
+    promptVariables = null,
   } = {}) {
     try {
       const id = this._ensurethreadId(threadId);
-      let input = this._convertItemsToApiFormat(additionalMessages);
+      
+      let input = context || this._convertItemsToApiFormat(additionalMessages);
       let allToolsExecuted = [];
       let totalRetries = 0;
       
-      // Handle pending function calls
-      if (assistant && toolOutputs.length === 0) {
-        const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
-        const result = await handlePendingFunctionCallsUtil(assistant, conversationMessages?.data || [], toolMetadata || { thread_id: id, assistant_id: assistantId });
-        toolOutputs = result.outputs || [];
-        allToolsExecuted = result.toolsExecuted || [];
-      }
+      input = input.filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
+
+      const promptConfig = promptVariables 
+        ? { id: assistantId, variables: promptVariables }
+        : { id: assistantId };
+      logger.info('[OpenAIResponsesProvider] Prompt config', { promptConfig });
 
-      input = [...input, ...toolOutputs];
       const makeAPICall = (inputData) => retryWithBackoff(() => 
         this.client.responses.create({
-          conversation: id,
-          prompt: { id: assistantId },
+          prompt: promptConfig,
           model: model || this.defaults.responseModel,
           instructions: additionalInstructions || instructions,
           input: inputData,
           metadata, top_p: topP, temperature, max_output_tokens: maxOutputTokens,
           truncation: truncationStrategy,
-          tools: transformToolsForResponsesAPIUtil(this.variant, tools),
         }), { providerName: PROVIDER_NAME });
 
       const { result: response, retries } = await makeAPICall(input);
       totalRetries += retries;
       let finalResponse = response;
 
+      // Handle function calls following OpenAI pattern
       if (assistant && response.output) {
         const functionCalls = response.output.filter(item => item.type === 'function_call');
         
         if (functionCalls.length > 0) {
           const { outputs, toolsExecuted } = await handleFunctionCallsUtil(functionCalls, assistant, toolMetadata || { thread_id: id, assistant_id: assistantId });
           
+          input.push(...response.output);
           input.push(...outputs);
           allToolsExecuted.push(...toolsExecuted);
 

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -5,13 +5,16 @@ async function executeFunctionCall(assistant, call, metadata = {}) {
   const name = call.name;
   const args = call.arguments ? JSON.parse(call.arguments) : {};
   
+  logger.info('[executeFunctionCall] Calling tool', { name, args, call_id: call.call_id });
+  
   let result, success = true;
   try {
     result = await assistant.executeTool(name, args);
+    logger.info('[executeFunctionCall] Tool completed', { name, call_id: call.call_id, duration_ms: Date.now() - startTime });
   } catch (error) {
     result = { error: error?.message || 'Tool execution failed' };
     success = false;
-    logger.error('[OpenAIResponsesProvider] Tool execution failed', { error });
+    logger.error('[executeFunctionCall] Tool execution failed', { name, call_id: call.call_id, error: error?.message });
   }
   
   const toolData = {

package/lib/providers/createProvider.js

@@ -1,5 +1,6 @@
 const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+const { DefaultConversationManager } = require('../services/DefaultConversationManager');
 const { logger } = require('../utils/logger');
 
 const PROVIDER_VARIANTS = {
@@ -16,8 +17,17 @@ function createProvider(config = {}) {
     .toString()
     .toLowerCase();
 
+  // Create conversation manager if not provided
+  const conversationManager = config.conversationManager || new DefaultConversationManager({
+    memorySystem: config.memorySystem
+  });
+
   const ProviderClass = PROVIDER_VARIANTS[variant] || OpenAIAssistantsProvider;
-  return new ProviderClass({ ...config, variant });
+  return new ProviderClass({ 
+    ...config, 
+    variant, 
+    conversationManager 
+  });
 }
 
 module.exports = {

package/lib/services/ConversationManager.js

@@ -0,0 +1,43 @@
+const { logger } = require('../utils/logger');
+
+class ConversationManager {
+  constructor(options = {}) {
+    this.memorySystem = options.memorySystem || null;
+  }
+
+  async buildContext({ thread, assistant, config = {} }) {
+    throw new Error('buildContext must be implemented by subclass');
+  }
+
+  async processResponse(response, thread, config = {}) {
+    throw new Error('processResponse must be implemented by subclass');
+  }
+
+  setMemorySystem(memorySystem) {
+    this.memorySystem = memorySystem;
+  }
+
+  getMemorySystem() {
+    return this.memorySystem;
+  }
+
+  optimizeContextWindow(messages, maxTokens = 8000) {
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const recentMessages = messages.filter(m => m.role !== 'system').slice(-20);
+    return [...systemMessages, ...recentMessages];
+  }
+
+  _convertToApiFormat(messages) {
+    return messages.map(msg => ({
+      role: msg.role || 'user',
+      content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+    }));
+  }
+
+  _logActivity(action, metadata = {}) {
+    logger.info(`[ConversationManager] ${action}`, metadata);
+  }
+}
+
+module.exports = { ConversationManager };

package/lib/services/DefaultConversationManager.js

@@ -0,0 +1,207 @@
+const { ConversationManager } = require('./ConversationManager');
+const { getLastNMessages } = require('../helpers/messageHelper');
+const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
+const { getRecordByFilter } = require('./airtableService');
+const { Follow_Up_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
+
+class DefaultConversationManager extends ConversationManager {
+  constructor(options = {}) {
+    super(options);
+    this.maxHistoricalMessages = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
+  }
+
+  async buildContext({ thread, assistant, config = {} }) {
+    this._logActivity('Building context', { threadCode: thread.code });
+
+    try {
+      const allMessages = await getLastNMessages(thread.code, this.maxHistoricalMessages);
+      const additionalMessages = config.additionalMessages || [];
+      
+      // New conversation - no history yet
+      if (!allMessages?.length) {
+        return additionalMessages;
+      }
+
+      const messageContext = allMessages.reverse().map(msg => ({
+        role: msg.origin === 'patient' ? 'user' : 'assistant',
+        content: msg.body || msg.content || ''
+      }));
+      
+      return [...additionalMessages, ...messageContext];
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Context building failed', {
+        threadCode: thread.code,
+        error: error.message
+      });
+      throw error;
+    }
+  }
+
+  async processResponse(response, thread, config = {}) {
+    this._logActivity('Processing response', { threadCode: thread.code, responseId: response.id });
+
+    try {
+      if (this.memorySystem && response.output) {
+        await this.memorySystem.processResponse(response, thread);
+      }
+      this._logActivity('Response processed successfully', {
+        threadCode: thread.code,
+        responseId: response.id
+      });
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Response processing failed', {
+        threadCode: thread.code,
+        error: error.message
+      });
+    }
+  }
+
+  async handlePendingFunctionCalls(assistant, conversationMessages, toolMetadata) {
+    if (!assistant || !conversationMessages?.length) return { outputs: [], toolsExecuted: [] };
+    
+    try {
+      return await handlePendingFunctionCallsUtil(assistant, conversationMessages, toolMetadata);
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Function call handling failed', { error: error.message });
+      return { outputs: [], toolsExecuted: [] };
+    }
+  }
+
+  optimizeContextWindow(messages) {
+    if (!Array.isArray(messages) || !messages.length) return [];
+    
+    const cappedMessages = messages.length > this.maxHistoricalMessages
+      ? messages.slice(-this.maxHistoricalMessages)
+      : messages;
+
+    if (messages.length > this.maxHistoricalMessages) {
+      this._logActivity('Context capped', { originalCount: messages.length, cappedCount: this.maxHistoricalMessages });
+    }
+
+    return this._convertToApiFormat(cappedMessages);
+  }
+
+  _convertToApiFormat(items) {
+    return items.map(item => ({
+      role: item.role || 'user',
+      content: this._normalizeContent(item.content),
+      type: item.type || 'message',
+    }));
+  }
+
+  _normalizeContent(content) {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) return content;
+    if (content?.text) return content.text;
+    if (content?.type === 'text' && content.text) return content.text;
+    return content && typeof content === 'object' ? JSON.stringify(content) : content || '';
+  }
+
+  async _getClinicalContext(whatsappId) {
+    try {
+      const [clinicalRecords, symptomsRecords] = await Promise.all([
+        getRecordByFilter(Follow_Up_ID, 'estado_general', `{whatsapp_id}='${whatsappId}'`),
+        getRecordByFilter(Follow_Up_ID, 'all_triages_last_month', `{whatsapp_id}='${whatsappId}'`)
+      ]);
+
+      let clinicalContext = null;
+      if (clinicalRecords && clinicalRecords.length > 0 && clinicalRecords[0]['clinical-context-json']) {
+        clinicalContext = JSON.parse(clinicalRecords[0]['clinical-context-json']);
+      }
+
+      const sortedSymptoms = symptomsRecords
+        ?.filter(r => r.Date)
+        .sort((a, b) => new Date(b.Date) - new Date(a.Date))
+        .slice(0, 3) || [];
+
+      const symptoms = this._parseSymptoms(sortedSymptoms);
+      
+      return { ...clinicalContext, symptoms };
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Error fetching clinical context', { error: error.message });
+      return null;
+    }
+  }
+
+  _parseSymptoms(records) {
+    if (!records || records.length === 0) return [];
+
+    return records.map(record => {
+      const symptomNames = record['symptom_name (from symptoms)'];
+      const grades = record['grade_num (from symptoms)'];
+      const recommendations = record['short_recommendations'];
+      const date = record['Date'];
+
+      if (!symptomNames || !grades) return null;
+
+      const nameArray = typeof symptomNames === 'string' 
+        ? symptomNames.split(',').map(s => s.trim())
+        : Array.isArray(symptomNames) ? symptomNames : [symptomNames];
+      
+      const gradeArray = typeof grades === 'string'
+        ? grades.split(',').map(g => parseInt(g.trim()))
+        : Array.isArray(grades) ? grades.map(g => parseInt(g)) : [parseInt(grades)];
+      
+      const recArray = recommendations && typeof recommendations === 'string'
+        ? recommendations.split('.,').map(r => r.trim())
+        : [];
+
+      const symptoms = nameArray
+        .map((name, idx) => ({
+          name,
+          grade: gradeArray[idx] || 0,
+          recommendation: recArray[idx] || ''
+        }))
+        .filter(s => s.grade > 0);
+
+      return {
+        date,
+        symptoms
+      };
+    }).filter(Boolean);
+  }
+
+  async getClinicalData(whatsappId) {
+    try {
+      const data = await this._getClinicalContext(whatsappId);
+      if (!data) return null;
+
+      // Format clinical context (demographics + clinical data)
+      const contextParts = [];
+      if (data.demografia) {
+        const d = data.demografia;
+        if (d.edad) contextParts.push(`Edad: ${d.edad}`);
+        if (d.sexo) contextParts.push(`Sexo: ${d.sexo}`);
+      }
+      if (data.datos_clinicos) {
+        const c = data.datos_clinicos;
+        if (c.diagnostico) contextParts.push(`Diagnóstico: ${c.diagnostico}`);
+        if (c.tratamiento_actual) contextParts.push(`Tratamiento actual: ${c.tratamiento_actual}`);
+        if (c.medicacion_actual) contextParts.push(`Medicación: ${c.medicacion_actual}`);
+        if (c.alergias_medicamentos) contextParts.push(`Alergias: ${c.alergias_medicamentos}`);
+        if (c.comorbilidades) contextParts.push(`Comorbilidades: ${c.comorbilidades}`);
+      }
+
+      // Format last symptoms
+      const symptomParts = [];
+      if (data.symptoms?.length > 0) {
+        data.symptoms.forEach(triage => {
+          const dateStr = new Date(triage.date).toLocaleDateString('es-PE');
+          const symptomsStr = triage.symptoms.map(s => `${s.name} (grado ${s.grade})`).join(', ');
+          if (symptomsStr) symptomParts.push(`${dateStr}: ${symptomsStr}`);
+        });
+      }
+
+      return {
+        clinicalContext: contextParts.join('. ') || '',
+        lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente'
+      };
+    } catch (error) {
+      logger.error('[DefaultConversationManager] Error getting clinical data', { error: error.message });
+      return null;
+    }
+  }
+}
+
+module.exports = { DefaultConversationManager };

package/lib/services/airtableService.js

@@ -52,7 +52,7 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view')
     });
     return records;
   } catch (error) {
-    logger.error(`Error fetching records by ${filter}:`, error);
+    logger.error(`Error fetching records from ${tableName} by ${filter}:`, error);
   }
 }
 

package/lib/services/assistantServiceCore.js

@@ -41,15 +41,6 @@ const createAssistantCore = async (code, assistant_id, messages = [], force = fa
   try {
     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
-      });
-    }
     
     const thread = {
       code: code,
@@ -76,17 +67,9 @@ const addMsgAssistantCore = async (code, inMessages, role = 'system', reply = fa
   const thread = await getThread(code);
   if (!thread) return null;
 
-  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const threadId = thread.getConversationId();
-
   try {
     const messages = Array.isArray(inMessages) ? inMessages : [inMessages];
 
-    await provider.addMessage({ 
-      threadId, 
-      messages: messages.map(message => ({ role, content: message }))
-    });
-
     // Save system messages to database for frontend visibility
     if (!skipSystemMessage) {
       for (let i = 0; i < messages.length; i++) {
@@ -205,12 +188,6 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     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`);
-      const threadId = finalThread.getConversationId();
-      await provider.addMessage({ threadId, messages: allMessagesToAdd });
-    }
 
     await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
     await cleanupFiles(allTempFiles);

package/lib/services/conversationService.js

@@ -21,9 +21,20 @@ const fetchConversationData = async (filter, skip, limit) => {
   
   const pipeline = [
     { $match: filterConditions },
-    { $project: { numero: 1, body: 1, createdAt: 1, timestamp: 1, media: 1, nombre_whatsapp: 1, from_me: 1 } },
-    { $sort: { createdAt: 1, timestamp: 1 } },
-    { $group: { _id: '$numero', latestMessage: { $last: '$$ROOT' }, messageCount: { $sum: 1 } } },
+    { $sort: { numero: 1, createdAt: -1 } },
+    { $group: { 
+      _id: '$numero', 
+      latestMessage: { $first: { 
+        _id: '$_id',
+        body: '$body',
+        createdAt: '$createdAt',
+        media: '$media',
+        nombre_whatsapp: '$nombre_whatsapp',
+        from_me: '$from_me'
+      } }, 
+      messageCount: { $sum: 1 } 
+    } },
+    { $match: { _id: { $nin: [null, ''] } } },
     ...(filter === 'no-response' ? [{ $match: { 'latestMessage.from_me': false } }] : []),
     {
       $lookup: {
@@ -40,22 +51,23 @@ const fetchConversationData = async (filter, skip, limit) => {
     },
     { $project: { threadInfo: 0 } },
     ...(filter === 'pending-review' ? [{ $match: { $or: [{ review: false }, { review: null }] } }] : []),
-    { $sort: { 'latestMessage.createdAt': -1, 'latestMessage.timestamp': -1 } },
+    { $sort: { 'latestMessage.createdAt': -1 } },
     { $skip: skip },
     { $limit: limit }
   ];
   
   const startTime = Date.now();
   const [conversations, contactNames, unreadCounts, totalResult] = await Promise.all([
-    Message.aggregate(pipeline),
-    Message.aggregate([{ $match: { ...baseMatch, from_me: false } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', name: { $first: '$nombre_whatsapp' } } }]),
-    Message.aggregate([{ $match: { ...baseMatch, ...unreadMatch } }, { $group: { _id: '$numero', unreadCount: { $sum: 1 } } }]),
+    Message.aggregate(pipeline, { allowDiskUse: true }),
+    Message.aggregate([{ $match: { ...baseMatch, from_me: false } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', name: { $first: '$nombre_whatsapp' } } }], { allowDiskUse: true }),
+    Message.aggregate([{ $match: { ...baseMatch, ...unreadMatch } }, { $group: { _id: '$numero', unreadCount: { $sum: 1 } } }], { allowDiskUse: true }),
     Message.aggregate(
       filter === 'no-response' 
-        ? [{ $match: baseMatch }, { $project: { numero: 1, from_me: 1, createdAt: 1, timestamp: 1 } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', latestMessage: { $first: '$$ROOT' } } }, { $match: { 'latestMessage.from_me': false } }, { $count: 'total' }]
+        ? [{ $match: baseMatch }, { $project: { numero: 1, from_me: 1, createdAt: 1 } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', latestMessage: { $first: '$$ROOT' } } }, { $match: { 'latestMessage.from_me': false } }, { $count: 'total' }]
         : filter === 'pending-review'
           ? [{ $match: baseMatch }, { $group: { _id: '$numero' } }, { $lookup: { from: 'threads', localField: '_id', foreignField: 'code', as: 'threadInfo' } }, { $addFields: { review: { $arrayElemAt: ['$threadInfo.review', 0] } } }, { $match: { $or: [{ review: false }, { review: null }] } }, { $count: 'total' }]
-          : [{ $match: filterConditions }, { $group: { _id: '$numero' } }, { $count: 'total' }]
+          : [{ $match: filterConditions }, { $group: { _id: '$numero' } }, { $count: 'total' }],
+      { allowDiskUse: true }
     )
   ]);
   

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -105,7 +105,7 @@
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.32.0",
     "baileys": "^6.4.0",
-    "express": "4.21.2",
+    "express": "4.22.1",
     "openai": "6.7.0",
     "twilio": "5.6.0"
   },