@peopl-health/nexus 3.0.3 → 3.0.5

package/lib/adapters/BaileysProvider.js

@@ -1,5 +1,6 @@
 const { MessageProvider } = require('../core/MessageProvider');
 const { logger } = require('../utils/logger');
+const { calculateDelay } = require('../utils/scheduleUtils');
 
 /**
  * Baileys WhatsApp messaging provider
@@ -150,7 +151,7 @@ class BaileysProvider extends MessageProvider {
 
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
-    const delay = this.calculateDelay(sendTime, timeZone);
+    const delay = calculateDelay(sendTime, timeZone);
 
     const sender = typeof __nexusSend === 'function'
       ? __nexusSend
@@ -181,11 +182,6 @@ class BaileysProvider extends MessageProvider {
     return { scheduled: true, delay };
   }
 
-  calculateDelay(sendTime) {
-    const now = new Date();
-    const targetTime = new Date(sendTime);
-    return Math.max(0, targetTime.getTime() - now.getTime());
-  }
 
   getConnectionStatus() {
     return this.waSocket?.user ? true : false;

package/lib/adapters/TwilioProvider.js

@@ -7,6 +7,7 @@ const { sanitizeMediaFilename } = require('../utils/sanitizer');
 const { generatePresignedUrl } = require('../config/awsConfig');
 const { validateMedia, getMediaType } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
+const { calculateDelay } = require('../utils/scheduleUtils');
 const { v4: uuidv4 } = require('uuid');
 
 /**
@@ -220,7 +221,7 @@ class TwilioProvider extends MessageProvider {
 
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
-    const delay = this.calculateDelay(sendTime, timeZone);
+    const delay = calculateDelay(sendTime, timeZone);
 
     const sender = typeof __nexusSend === 'function'
       ? __nexusSend
@@ -423,11 +424,6 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
-  calculateDelay(sendTime) {
-    const now = new Date();
-    const targetTime = new Date(sendTime);
-    return Math.max(0, targetTime.getTime() - now.getTime());
-  }
 
   /**
    * Split a message into chunks at sentence boundaries, respecting Twilio's character limit

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
     };
   }
 
@@ -656,6 +661,20 @@ class NexusMessaging {
     
     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;
     }
 
@@ -668,33 +687,53 @@ class NexusMessaging {
   async _processWithLock(chatId, existingTypingInterval = null) {
     this.processingLocks.set(chatId, true);
     let typingInterval = existingTypingInterval;
+    let runId = null;
 
     try {
       if (!typingInterval) {
         typingInterval = await this._startTypingRefresh(chatId);
       }
-      logger.info(`[CheckAfter] Processing messages for ${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`);
+
+      runId = `run_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+      this.activeRequests.set(chatId, runId);
 
-      const result = await replyAssistant(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;
 
-      // 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);
+      if (typingInterval) {
+        clearInterval(typingInterval);
+        typingInterval = null;
       }
 
-      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -712,9 +751,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
    */
@@ -726,10 +781,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/helpers/mediaHelper.js

@@ -10,13 +10,13 @@ async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, content
   const fileName = sanitizedTitle 
     ? `${messageType}/${messageID}_${sanitizedTitle}.${extension}`
     : `${messageType}/${messageID}.${extension}`;
-  logger.info(titleFile, messageType);
+  logger.info('[uploadMediaToS3] Media file prepared for upload', { fileName, messageType });
     
   try {
     await AWS.uploadBufferToS3(buffer, bucketName, fileName, contentType);
     return fileName;
   } catch (error) {
-    logger.error('Failed to upload media to S3:', error.stack);
+    logger.error('[uploadMediaToS3] Failed to upload media to S3:', error.stack);
     throw error;
   }
 }

package/lib/helpers/messageHelper.js

@@ -2,19 +2,31 @@ const moment = require('moment-timezone');
 const { Message } = require('../models/messageModel.js');
 const { logger } = require('../utils/logger');
 
-const updateMessageRecord = async (reply, thread) => {
+const updateMessageRecord = async (reply, thread, processedContent = null) => {
   const threadId = thread.getConversationId();
   
+  const updateData = { 
+    assistant_id: thread.getAssistantId(), 
+    thread_id: threadId,
+    processed: true 
+  };
+  
+  if (processedContent && reply.media) {
+    updateData.media = {
+      ...reply.media,
+      metadata: {
+        ...(reply.media.metadata || {}),
+        processed_content: processedContent
+      }
+    };
+  }
+  
   await Message.updateOne(
     { message_id: reply.message_id, timestamp: reply.timestamp },
-    { $set: { 
-      assistant_id: thread.getAssistantId(), 
-      thread_id: threadId,
-      processed: true 
-    } }
+    { $set: updateData }
   );
   
-  logger.info(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true`);
+  logger.info(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true, MediaContentUpdated: ${!!(processedContent && reply.media)}`);
 };
 
 
@@ -81,7 +93,12 @@ function formatMessage(reply) {
       .locale('es')
       .format('dddd, D [de] MMMM [de] YYYY [a las] h:mm A');
     
-    return `[${mexicoCityTime}] ${reply.body}`;
+    let messageContent = reply.body;
+    if (reply.media?.metadata?.processed_content) {
+      messageContent = reply.media.metadata.processed_content;
+    }
+    
+    return `[${mexicoCityTime}] ${messageContent}`;
   } catch (error) {
     logger.error(`[formatMessage] Error for message ID: ${reply.message_id}:`, error?.message || String(error));
     return null;

package/lib/helpers/processHelper.js

@@ -35,23 +35,19 @@ const logger = {
 
 /**
  * Dedicated message processing utilities
- * Handles text messages, media files, audio transcription, and thread operations
  */
 const processTextMessage = (reply) => {
-  const formattedMessage = formatMessage(reply);
   logger.info('processTextMessage', { 
     message_id: reply.message_id,
     timestamp: reply.timestamp,
     from_me: reply.from_me,
     body: reply.body,
-    hasContent: !!formattedMessage,
-    formattedMessage
+    hasContent: !!reply.body
   });
-  logger.debug('processTextMessage_content', { formattedMessage });
   
   const messagesChat = [];
-  if (formattedMessage) {
-    messagesChat.push({ type: 'text', text: formattedMessage });
+  if (reply.body) {
+    messagesChat.push({ type: 'text', text: reply.body });
   }
   
   return messagesChat;
@@ -121,8 +117,6 @@ const processImageFileCore = async (fileName, reply) => {
       ...timings
     });
     
-    logger.debug('processImageFile_analysis', { imageAnalysis });
-    
   } catch (error) {
     logger.error('processImageFile', error, {
       message_id: reply.message_id,

package/lib/helpers/qrHelper.js

@@ -12,12 +12,6 @@ async function generateQRBuffer(text) {
   }
 }
 
-function bufferToBase64(buffer) {
-  return buffer.toString('base64');
-}
-
-
 module.exports = {
-  generateQRBuffer,
-  bufferToBase64
+  generateQRBuffer
 };

package/lib/helpers/twilioHelper.js

@@ -1,4 +1,3 @@
-const { Message } = require('../models/messageModel.js');
 const { isRecentMessage } = require('./messageHelper.js');
 const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
@@ -57,15 +56,27 @@ async function downloadMediaFromTwilio(mediaUrl, logger) {
 
     return Buffer.from(response.data);
   } catch (error) {
+    const is404 = error.response?.status === 404;
+    const isMediaExpired = is404 && mediaUrl.includes('/Media/');
+    
     logger.error('[TwilioMedia] Download failed', {
       message: error.message,
       status: error.response?.status,
       statusText: error.response?.statusText,
+      isMediaExpired,
       responseHeaders: error.response?.headers,
       responseData: error.response?.data ? error.response.data.toString().substring(0, 500) : null,
       url: mediaUrl,
       hasCredentials: !!(process.env.TWILIO_ACCOUNT_SID && process.env.TWILIO_AUTH_TOKEN)
     });
+    
+    if (isMediaExpired) {
+      logger.warn('[TwilioMedia] Media expired (24h limit), skipping download', {
+        mediaId: mediaUrl.split('/').pop()
+      });
+      return null;
+    }
+    
     throw error;
   }
 }
@@ -89,16 +100,6 @@ function extractTitle(message, mediaType) {
 }
 
 
-async function getLastMessages(chatId, n) {
-  const messages = await Message.find({ numero: chatId })
-    .sort({ createdAt: -1 })
-    .limit(n)
-    .select('timestamp numero nombre_whatsapp body');
-
-  return messages.map(msg => `[${msg.timestamp}] ${msg.body}`);
-}
-
-
 async function downloadMedia(twilioMessage, logger) {
   try {
     const mediaUrl = twilioMessage.MediaUrl0;
@@ -145,7 +146,6 @@ module.exports = {
   getMediaTypeFromContentType,
   extractTitle,
   isRecentMessage,
-  getLastMessages,
   downloadMedia,
   ensureWhatsAppFormat
 };

package/lib/helpers/twilioMediaProcessor.js

@@ -82,6 +82,11 @@ async function processTwilioMediaMessage(twilioMessage, bucketName) {
       continue;
     }
 
+    if (!mediaBuffer) {
+      logger.info('[TwilioMedia] Skipping expired media', { index: i, mediaUrl });
+      continue;
+    }
+
     const validationResult = validateMedia(mediaBuffer, contentType);
     if (!validationResult.valid) {
       logger.warn('[TwilioMedia] Media validation warning', { index: i, message: validationResult.message });

package/lib/helpers/whatsappHelper.js

@@ -1,12 +1,6 @@
-const moment = require('moment-timezone');
 const { logger } = require('../utils/logger');
 
 
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-
 function formatCode(codeBase) {
   logger.info(`formatCode ${codeBase}`);
 
@@ -37,40 +31,6 @@ function formatCode(codeBase) {
 }
 
 
-function calculateDelay(sendTime, timeZone) {
-  if (sendTime !== undefined && timeZone !== undefined) {
-    const sendMoment = moment.tz(sendTime, timeZone);
-
-    if (!sendMoment.isValid()) {
-      return { error: 'Invalid time format' };
-    }
-
-    // Get the current time and calculate the difference
-    const now = moment().tz(timeZone);
-    const randomDelay = Math.floor(Math.random() * 15001) + 15000;
-    const delay = sendMoment.diff(now) + randomDelay;
-
-    // Log the calculated details for debugging
-    logger.info(
-      'Scheduled Time:', sendMoment.format(), 
-      'Current Time:', now.format(), 
-      'Delay (minutes):', delay / 60000, 
-      'Remaining Seconds:', delay % 60000
-    );
-
-    if (delay <= 0) {
-      return 2500;
-    }
-
-    return delay;
-  } else {
-    return 2500;
-  }
-}
-
-
 module.exports = {
-  delay,
-  formatCode,
-  calculateDelay
+  formatCode
 };

package/lib/index.d.ts

@@ -283,7 +283,6 @@ declare module '@peopl-health/nexus' {
 
   // Utility Functions
   export function createLogger(config?: any): any;
-  export function delay(ms: number): Promise<void>;
   export function formatCode(codeBase: string): string;
   export function calculateDelay(sendTime: string | Date, timeZone?: string): number;
   export function ensureWhatsAppFormat(phoneNumber: any): string | null;

package/lib/{services/DefaultConversationManager.js → memory/DefaultMemoryManager.js}

@@ -1,11 +1,11 @@
-const { ConversationManager } = require('./ConversationManager');
+const { MemoryManager } = require('./MemoryManager');
 const { getLastNMessages, formatMessage } = require('../helpers/messageHelper');
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
-const { getRecordByFilter } = require('./airtableService');
+const { getRecordByFilter } = require('../services/airtableService');
 const { Follow_Up_ID } = require('../config/airtableConfig');
 const { logger } = require('../utils/logger');
 
-class DefaultConversationManager extends ConversationManager {
+class DefaultMemoryManager extends MemoryManager {
   constructor(options = {}) {
     super(options);
     this.maxHistoricalMessages = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
@@ -18,7 +18,6 @@ class DefaultConversationManager extends ConversationManager {
       const allMessages = await getLastNMessages(thread.code, this.maxHistoricalMessages);
       const additionalMessages = config.additionalMessages || [];
       
-      // New conversation - no history yet
       if (!allMessages?.length) {
         return additionalMessages;
       }
@@ -33,7 +32,7 @@ class DefaultConversationManager extends ConversationManager {
       
       return [...additionalMessages, ...messageContext];
     } catch (error) {
-      logger.error('[DefaultConversationManager] Context building failed', {
+      logger.error('[DefaultMemoryManager] Context building failed', {
         threadCode: thread.code,
         error: error.message
       });
@@ -53,7 +52,7 @@ class DefaultConversationManager extends ConversationManager {
         responseId: response.id
       });
     } catch (error) {
-      logger.error('[DefaultConversationManager] Response processing failed', {
+      logger.error('[DefaultMemoryManager] Response processing failed', {
         threadCode: thread.code,
         error: error.message
       });
@@ -66,7 +65,7 @@ class DefaultConversationManager extends ConversationManager {
     try {
       return await handlePendingFunctionCallsUtil(assistant, conversationMessages, toolMetadata);
     } catch (error) {
-      logger.error('[DefaultConversationManager] Function call handling failed', { error: error.message });
+      logger.error('[DefaultMemoryManager] Function call handling failed', { error: error.message });
       return { outputs: [], toolsExecuted: [] };
     }
   }
@@ -122,7 +121,7 @@ class DefaultConversationManager extends ConversationManager {
       
       return { ...clinicalContext, symptoms };
     } catch (error) {
-      logger.error('[DefaultConversationManager] Error fetching clinical context', { error: error.message });
+      logger.error('[DefaultMemoryManager] Error fetching clinical context', { error: error.message });
       return null;
     }
   }
@@ -201,10 +200,10 @@ class DefaultConversationManager extends ConversationManager {
         lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente'
       };
     } catch (error) {
-      logger.error('[DefaultConversationManager] Error getting clinical data', { error: error.message });
+      logger.error('[DefaultMemoryManager] Error getting clinical data', { error: error.message });
       return null;
     }
   }
 }
 
-module.exports = { DefaultConversationManager };
+module.exports = { DefaultMemoryManager };

package/lib/{services/ConversationManager.js → memory/MemoryManager.js}

@@ -1,6 +1,6 @@
 const { logger } = require('../utils/logger');
 
-class ConversationManager {
+class MemoryManager {
   constructor(options = {}) {
     this.memorySystem = options.memorySystem || null;
   }
@@ -36,8 +36,8 @@ class ConversationManager {
   }
 
   _logActivity(action, metadata = {}) {
-    logger.info(`[ConversationManager] ${action}`, metadata);
+    logger.info(`[MemoryManager] ${action}`, metadata);
   }
 }
 
-module.exports = { ConversationManager };
+module.exports = { MemoryManager };

package/lib/providers/OpenAIResponsesProvider.js

@@ -4,8 +4,9 @@ const { retryWithBackoff } = require('../utils/retryHelper');
 const {
   handleFunctionCalls: handleFunctionCallsUtil,
 } = require('./OpenAIResponsesProviderTools');
-const { DefaultConversationManager } = require('../services/DefaultConversationManager');
+const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 const { logger } = require('../utils/logger');
+const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
@@ -41,7 +42,7 @@ class OpenAIResponsesProvider {
     };
 
     this.variant = 'responses';
-    this.conversationManager = conversationManager || new DefaultConversationManager();
+    this.conversationManager = conversationManager || new DefaultMemoryManager();
 
     this.responses = this.client.responses;
     this.conversations = this.client.conversations;
@@ -196,13 +197,20 @@ class OpenAIResponsesProvider {
         }
       });
 
+      logger.info('[OpenAIResponsesProvider] Context built', {
+        conversationId,
+        assistantId,
+        context
+      });
+
       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 || ''
+        last_symptoms: clinicalData.lastSymptoms || '',
+        current_date: getCurrentMexicoDateTime(),
       } : null;
 
       // Execute with built context

package/lib/providers/createProvider.js

@@ -1,6 +1,6 @@
 const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
-const { DefaultConversationManager } = require('../services/DefaultConversationManager');
+const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 const { logger } = require('../utils/logger');
 
 const PROVIDER_VARIANTS = {
@@ -18,7 +18,7 @@ function createProvider(config = {}) {
     .toLowerCase();
 
   // Create conversation manager if not provided
-  const conversationManager = config.conversationManager || new DefaultConversationManager({
+  const conversationManager = config.conversationManager || new DefaultMemoryManager({
     memorySystem: config.memorySystem
   });
 

package/lib/services/assistantServiceCore.js

@@ -10,7 +10,7 @@ const { Historial_Clinico_ID } = require('../config/airtableConfig');
 const { getCurRow, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
 const { getThread } = require('../helpers/threadHelper.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
-const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
+const { getLastNMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { getAssistantById } = require('./assistantResolver');
 const { logger } = require('../utils/logger');
@@ -156,18 +156,18 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     const finalThread = thread;
 
     const messagesStart = Date.now();
-    const patientReply = await getLastMessages(code);
+    const lastMessage = await getLastNMessages(code, 1);
     timings.get_messages_ms = Date.now() - messagesStart;
     
-    if (!patientReply) {
+    if (!lastMessage || lastMessage.length === 0 || lastMessage[0].from_me) {
       logger.info('[replyAssistantCore] No relevant data found for this assistant.');
       return null;
     }
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+    logger.info(`[replyAssistantCore] Processing ${lastMessage.length} messages in parallel`);
     const processStart = Date.now();
-    const processResult = await processThreadMessage(code, patientReply, provider);
+    const processResult = await processThreadMessage(code, lastMessage, provider);
     
     const { results: processResults, timings: processTimings } = processResult;
     timings.process_messages_ms = Date.now() - processStart;
@@ -186,10 +186,14 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     const patientMsg = processResults.some(r => r.isPatient);
     const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
-    const allMessagesToAdd = processResults.flatMap(r => r.messages || []);
     const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
 
-    await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
+    await Promise.all(processResults.map(r => {
+      const processedContent = r.messages && r.messages.length > 0 
+        ? r.messages.map(msg => msg.content.text).join(' ')
+        : null;
+      return updateMessageRecord(r.reply, finalThread, processedContent);
+    }));
     await cleanupFiles(allTempFiles);
 
     if (urls.length > 0) {
@@ -217,7 +221,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
     const runStart = Date.now();
-    const runResult = await runAssistantWithRetries(finalThread, assistant, runOptions, patientReply);
+    const runResult = await runAssistantWithRetries(finalThread, assistant, runOptions, lastMessage);
     timings.run_assistant_ms = Date.now() - runStart;
     timings.total_ms = Date.now() - startTotal;
     
@@ -225,7 +229,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     logger.info('[Assistant Reply Complete]', {
       code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-      messageCount: patientReply.length,
+      messageCount: lastMessage.length,
       hasMedia: urls.length > 0,
       retries,
       totalMs: timings.total_ms,

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/lib/utils/index.js

@@ -1,9 +1,11 @@
 const { MessageParser } = require('./messageParser');
 const { logger } = require('./logger');
 const { retryWithBackoff } = require('./retryHelper');
+const { calculateDelay } = require('./scheduleUtils');
 
 module.exports = {
   MessageParser,
   logger,
   retryWithBackoff,
+  calculateDelay,
 };

package/lib/utils/scheduleUtils.js

@@ -0,0 +1,57 @@
+const moment = require('moment-timezone');
+const { logger } = require('./logger');
+
+/**
+ * Calculate delay in milliseconds until a scheduled time
+ */
+function calculateDelay(sendTime, timeZone) {
+  if (!sendTime) {
+    return 2500;
+  }
+
+  try {
+    if (timeZone && typeof sendTime === 'string') {
+      const sendMoment = moment.tz(sendTime, timeZone);
+      
+      if (!sendMoment.isValid()) {
+        logger.warn('[calculateDelay] Invalid time format', { sendTime, timeZone });
+        return 2500;
+      }
+
+      const now = moment().tz(timeZone);
+      const randomDelay = Math.floor(Math.random() * 5001) + 10000;
+      const delay = sendMoment.diff(now) + randomDelay;
+
+      logger.debug('[calculateDelay] Timezone calculation', {
+        scheduledTime: sendMoment.format(),
+        currentTime: now.format(),
+        delayMinutes: delay / 60000,
+        timeZone
+      });
+
+      return Math.max(0, delay);
+    }
+
+    const now = new Date();
+    const targetTime = new Date(sendTime);
+    
+    if (isNaN(targetTime.getTime())) {
+      logger.warn('[calculateDelay] Invalid date format', { sendTime });
+      return 2500;
+    }
+
+    return Math.max(0, targetTime.getTime() - now.getTime());
+
+  } catch (error) {
+    logger.error('[calculateDelay] Error calculating delay', { 
+      error: error.message, 
+      sendTime, 
+      timeZone 
+    });
+    return 2500;
+  }
+}
+
+module.exports = {
+  calculateDelay
+};

package/package.json

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