@peopl-health/nexus 3.0.2 → 3.0.4

package/lib/core/NexusMessaging.js

@@ -43,9 +43,14 @@ class NexusMessaging {
     };
     // Message processing with check-after strategy
     this.processingLocks = new Map(); // Per-chat locks to prevent parallel processing
+    this.activeRequests = new Map(); // Track active AI requests per chat
+    this.abandonedRuns = new Set(); // Track runs that should be ignored
     this.batchingConfig = {
       enabled: config.messageBatching?.enabled ?? true, // Enabled by default with check-after
-      checkDelayMs: config.messageBatching?.checkDelayMs ?? 100 // Delay before checking for new messages
+      abortOnNewMessage: config.messageBatching?.abortOnNewMessage ?? true, // Abort ongoing AI calls when new messages arrive
+      immediateRestart: config.messageBatching?.immediateRestart ?? true, // Start new processing immediately without waiting
+      batchWindowMs: config.messageBatching?.batchWindowMs ?? 2000, // Wait up to 2s for message bursts
+      maxBatchWait: config.messageBatching?.maxBatchWait ?? 5000 // Maximum time to wait for batching
     };
   }
 
@@ -348,6 +353,7 @@ class NexusMessaging {
     if (this.messageStorage) {
       await this.messageStorage.saveMessage({
         ...messageData,
+        messageId: messageData.id,
         timestamp: new Date(),
         fromMe: false,
         origin: 'patient'
@@ -651,49 +657,78 @@ class NexusMessaging {
    * Handle message with check-after strategy - process immediately, check for new messages after
    */
   async _handleWithCheckAfter(chatId) {
-    // If already processing this chat, just return (message is saved, will be picked up)
+    const typingInterval = await this._startTypingRefresh(chatId);
+    
     if (this.processingLocks.has(chatId)) {
       logger.info(`[CheckAfter] Already processing ${chatId}, new message will be included`);
+      
+      if (this.batchingConfig.abortOnNewMessage && this.activeRequests.has(chatId)) {
+        const runId = this.activeRequests.get(chatId);
+        this.abandonedRuns.add(runId);
+        logger.info(`[CheckAfter] Marked run ${runId} as abandoned for ${chatId}`);
+        
+        if (this.batchingConfig.immediateRestart) {
+          this.processingLocks.delete(chatId);
+          this.activeRequests.delete(chatId);
+          
+          logger.info(`[CheckAfter] Starting immediate reprocessing for ${chatId}`);
+          await this._processWithLock(chatId, null);
+        }
+      }
       return;
     }
 
-    await this._processWithLock(chatId);
+    await this._processWithLock(chatId, typingInterval);
   }
 
   /**
    * Process messages with per-chat lock and check-after logic
    */
-  async _processWithLock(chatId) {
+  async _processWithLock(chatId, existingTypingInterval = null) {
     this.processingLocks.set(chatId, true);
-    let typingInterval = null;
+    let typingInterval = existingTypingInterval;
+    let runId = null;
 
     try {
-      typingInterval = await this._startTypingRefresh(chatId);
-      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));
+      if (!typingInterval) {
+        typingInterval = await this._startTypingRefresh(chatId);
+      }
+      
+      const startTime = Date.now();
+      let messageCount = await this._getUnprocessedMessageCount(chatId);
+      let lastCount = messageCount;
+      
+      while (Date.now() - startTime < this.batchingConfig.batchWindowMs) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const newCount = await this._getUnprocessedMessageCount(chatId);
+        
+        if (newCount > lastCount) {
+          lastCount = newCount;
+          logger.info(`[Batching] New message detected for ${chatId}, extending wait`);
+        }
+        
+        if (Date.now() - startTime >= this.batchingConfig.maxBatchWait) {
+          logger.info(`[Batching] Max wait reached for ${chatId}`);
+          break;
+        }
+      }
+      
+      logger.info(`[CheckAfter] Processing ${lastCount} messages for ${chatId} after batching`);
 
-      // Check for new unprocessed messages
-      const hasNewMessages = await Message.exists({
-        numero: chatId,
-        processed: false,
-        from_me: false
-      });
+      runId = `run_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+      this.activeRequests.set(chatId, runId);
 
-      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);
+      const result = await replyAssistant(chatId, null, null, { runId });
+      
+      if (this.abandonedRuns.has(runId)) {
+        logger.info(`[CheckAfter] Discarding abandoned run ${runId} for ${chatId}`);
+        this.abandonedRuns.delete(runId);
+        return;
       }
+      
+      const botResponse = typeof result === 'string' ? result : result?.output;
+      const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
 
-      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -711,9 +746,25 @@ class NexusMessaging {
     } finally {
       if (typingInterval) clearInterval(typingInterval);
       this.processingLocks.delete(chatId);
+      this.activeRequests.delete(chatId);
+      if (this.abandonedRuns.size > 100) {
+        this.abandonedRuns.clear();
+      }
     }
   }
 
+  /**
+   * Get count of unprocessed messages for a chat
+   */
+  async _getUnprocessedMessageCount(chatId) {
+    const { Message } = require('../models/messageModel');
+    return await Message.countDocuments({
+      numero: chatId,
+      processed: false,
+      from_me: false
+    });
+  }
+
   /**
    * Start typing indicator refresh interval
    */
@@ -725,10 +776,16 @@ class NexusMessaging {
     const lastMessage = await Message.findOne({ 
       numero: chatId, 
       from_me: false,
-      message_id: { $exists: true, $ne: null }
+      processed: false,
+      message_id: { $exists: true, $ne: null, $not: /^pending-/ }
     }).sort({ createdAt: -1 });
     
-    if (!lastMessage?.message_id) return null;
+    if (!lastMessage?.message_id) {
+      logger.debug(`[_startTypingRefresh] No valid message for typing indicator: ${chatId}`);
+      return null;
+    }
+    
+    logger.debug(`[_startTypingRefresh] Starting typing indicator for message: ${lastMessage.message_id}`);
     
     return setInterval(() => 
       this.provider.sendTypingIndicator(lastMessage.message_id).catch(err => 

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

@@ -6,6 +6,7 @@ const {
 } = require('./OpenAIResponsesProviderTools');
 const { DefaultConversationManager } = require('../services/DefaultConversationManager');
 const { logger } = require('../utils/logger');
+const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
@@ -202,7 +203,8 @@ class OpenAIResponsesProvider {
       const clinicalData = await this.conversationManager.getClinicalData(thread.code);
       const promptVariables = clinicalData ? {
         clinical_context: clinicalData.clinicalContext || '',
-        last_symptoms: clinicalData.lastSymptoms || ''
+        last_symptoms: clinicalData.lastSymptoms || '',
+        current_date: getCurrentMexicoDateTime(),
       } : null;
 
       // Execute with built context
@@ -287,10 +289,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/lib/utils/dateUtils.js

@@ -18,9 +18,17 @@ const dateAndTimeFromStart = (startTime) => {
   };
 };
 
+const getCurrentMexicoDateTime = () => {
+  return moment()
+    .tz('America/Mexico_City')
+    .locale('es')
+    .format('dddd, D [de] MMMM [de] YYYY [a las] h:mm A');
+};
+
 module.exports = {
   ISO_DATE,
   parseStartTime,
   addDays,
-  dateAndTimeFromStart
+  dateAndTimeFromStart,
+  getCurrentMexicoDateTime
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "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"
   },