@peopl-health/nexus 2.5.11 → 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', 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:', 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})`);
 
@@ -83,8 +83,8 @@ const getConversationController = async (req, res) => {
     logger.info('Response sent successfully!');
 
   } catch (error) {
-    logger.error('Error fetching conversations:', error);
-    logger.error('Error stack:', error.stack);
+    logger.error('Error fetching conversations:', { error });
+    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', 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:', 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:', msg._id);
+              logger.warn(`Found media message with Buffer data that might cause serialization issues: ${msg._id}`);
               return true;
             }
           }
@@ -157,13 +156,14 @@ 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 });
+      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,7 +197,8 @@ 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 });
+    logger.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, { error });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversation'
@@ -206,7 +207,7 @@ const getConversationMessagesController = async (req, res) => {
 };
 
 const getConversationReplyController = async (req, res) => {
-  logger.info('Starting getConversationReplyController at', 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.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 });
+    logger.error('Responding with error:', { errorMsg });
     res.status(500).json({
       success: false,
       error: errorMsg
@@ -361,7 +364,8 @@ 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 });
+            logger.error('Error fetching Airtable batch for search:', { error });
             return [];
           });
         });
@@ -380,7 +384,8 @@ 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 });
+        logger.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', { error });
       }
     }
 
@@ -445,7 +450,8 @@ const searchConversationsController = async (req, res) => {
     });
 
   } catch (error) {
-    logger.error('Error searching conversations:', error);
+    logger.error('Error searching conversations:', { error });
+    logger.error('Error searching conversations:', { error });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to search conversations'
@@ -478,7 +484,8 @@ const getConversationsByNameController = async (req, res) => {
       }))
     });
   } catch (error) {
-    logger.error('Error fetching conversations by name:', error);
+    logger.error('Error fetching conversations by name:', { error });
+    logger.error('Error fetching conversations by name:', { error });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversations by name'
@@ -524,7 +531,8 @@ 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 });
+    logger.error(`Error fetching new messages for ${req.params.phoneNumber}:`, { error });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch new messages'
@@ -533,7 +541,7 @@ const getNewMessagesController = async (req, res) => {
 };
 
 const markMessagesAsReadController = async (req, res) => {
-  logger.info('Starting markMessagesAsReadController at', 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, 
@@ -563,8 +571,8 @@ const markMessagesAsReadController = async (req, res) => {
       modifiedCount: result.nModified || result.modifiedCount
     });
   } catch (error) {
-    logger.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, error);
-    logger.error('Error stack:', error.stack);
+    logger.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, { error });
+    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', new Date().toISOString());
+  logger.info(`Starting sendTemplateToNewNumberController at ${new Date().toISOString()}`);
   try {
     const { phoneNumber, templateId, variables } = req.body;
     
@@ -618,7 +626,8 @@ 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 });
+    logger.error('Error sending template to new number:', { error });
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to send template to new number'
@@ -627,14 +636,14 @@ const sendTemplateToNewNumberController = async (req, res) => {
 };
 
 const getOpenAIThreadMessagesController = async (req, res) => {
-  logger.info('Starting getOpenAIThreadMessagesController at', 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:', provider.getVariant());
+    logger.info(`Using provider variant: ${provider.getVariant()}`);
     
     const queryParams = { 
       threadId: conversationId, 
@@ -679,7 +688,8 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     let messages;
     let threadRecreated = false;
     
-    logger.info('Calling listMessages with params:', queryParams);
+    logger.info('Calling listMessages with params:', { queryParams });
+    logger.info('Calling listMessages with params:', { queryParams });
     messages = await withThreadRecovery(
       async (currentThread = thread) => {
         if (currentThread !== thread) {
@@ -712,8 +722,8 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     });
     
   } catch (error) {
-    logger.error('Error fetching OpenAI thread messages:', error);
-    logger.error('Error stack:', error.stack);
+    logger.error('Error fetching OpenAI thread messages:', { error });
+    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();