@peopl-health/nexus 3.0.1 → 3.0.3

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/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
     };
   }
 
@@ -348,6 +348,7 @@ class NexusMessaging {
     if (this.messageStorage) {
       await this.messageStorage.saveMessage({
         ...messageData,
+        messageId: messageData.id,
         timestamp: new Date(),
         fromMe: false,
         origin: 'patient'
@@ -393,10 +394,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 +649,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
+  async _handleWithCheckAfter(chatId) {
     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;
+    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, typingInterval);
   }
 
   /**
-   * Process all batched messages for a chat
+   * Process messages with per-chat lock and check-after logic
    */
-  async _handleBatchedMessages(chatId) {
-    let typingInterval = null;
-    
+  async _processWithLock(chatId, existingTypingInterval = null) {
+    this.processingLocks.set(chatId, true);
+    let typingInterval = existingTypingInterval;
+
     try {
-      logger.info(`Processing batched messages from ${chatId} (including media if any)`);
-      
-      typingInterval = await this._startTypingRefresh(chatId);
-      
-      // Get assistant response
+      if (!typingInterval) {
+        typingInterval = await this._startTypingRefresh(chatId);
+      }
+      logger.info(`[CheckAfter] Processing messages for ${chatId}`);
+
       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`);
+        return await this._processWithLock(chatId, typingInterval);
+      }
+
+      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -729,40 +704,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/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

@@ -287,10 +287,7 @@ class OpenAIResponsesProvider {
       const makeAPICall = (inputData) => retryWithBackoff(() => 
         this.client.responses.create({
           prompt: promptConfig,
-          model: model || this.defaults.responseModel,
-          instructions: additionalInstructions || instructions,
           input: inputData,
-          metadata, top_p: topP, temperature, max_output_tokens: maxOutputTokens,
           truncation: truncationStrategy,
         }), { providerName: PROVIDER_NAME });
 

package/lib/services/DefaultConversationManager.js

@@ -1,5 +1,5 @@
 const { ConversationManager } = require('./ConversationManager');
-const { getLastNMessages } = require('../helpers/messageHelper');
+const { getLastNMessages, formatMessage } = require('../helpers/messageHelper');
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
 const { getRecordByFilter } = require('./airtableService');
 const { Follow_Up_ID } = require('../config/airtableConfig');
@@ -23,10 +23,13 @@ class DefaultConversationManager extends ConversationManager {
         return additionalMessages;
       }
 
-      const messageContext = allMessages.reverse().map(msg => ({
-        role: msg.origin === 'patient' ? 'user' : 'assistant',
-        content: msg.body || msg.content || ''
-      }));
+      const messageContext = allMessages.reverse().map(msg => {
+        const formattedContent = formatMessage(msg);
+        return {
+          role: msg.origin === 'patient' ? 'user' : 'assistant',
+          content: formattedContent || msg.body || msg.content || ''
+        };
+      });
       
       return [...additionalMessages, ...messageContext];
     } catch (error) {

package/lib/services/conversationService.js

@@ -41,22 +41,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": "3.0.1",
+  "version": "3.0.3",
   "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.22.1",
+    "express": "^4.22.1",
     "openai": "6.7.0",
     "twilio": "5.6.0"
   },