@peopl-health/nexus 2.7.1 → 2.8.0

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

@@ -3,10 +3,11 @@ const axios = require('axios');
 const runtimeConfig = require('../config/runtimeConfig');
 const { uploadMediaToS3, getFileExtension } = require('../helpers/mediaHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
-const { sanitizeMediaFilename } = require('../utils/sanitizer');
+const { sanitizeMediaFilename } = require('../utils/inputSanitizer');
 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/controllers/bugReportController.js

@@ -46,8 +46,8 @@ const reportBugController = async (req, res) => {
 
     if (!reporter) return res.status(400).json({ success: false, error: 'Reporter username is required' });
     if (!whatsapp_id) return res.status(400).json({ success: false, error: 'WhatsApp ID is required' });
-    if (!severity || !['low', 'medium', 'high'].includes(severity)) {
-      return res.status(400).json({ success: false, error: 'Severity must be low, medium, or high' });
+    if (!severity || !['low', 'medium', 'high', 'critical'].includes(severity)) {
+      return res.status(400).json({ success: false, error: 'Severity must be low, medium, high, or critical' });
     }
 
     logBugReportToAirtable(reporter, whatsapp_id, description, severity, messages).catch(err =>

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,83 @@ 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}`);
+      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`);
 
-      // Process with assistant
-      const result = await replyAssistant(chatId);
+      runId = `run_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+      this.activeRequests.set(chatId, runId);
+
+      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`);
-        if (typingInterval) clearInterval(typingInterval);
-        // Recursively process with new messages
-        return await this._processWithLock(chatId);
+      if (typingInterval) {
+        clearInterval(typingInterval);
+        typingInterval = null;
       }
 
-      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -711,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
    */
@@ -725,10 +781,16 @@ class NexusMessaging {
     const lastMessage = await Message.findOne({ 
       numero: chatId, 
       from_me: false,
-      message_id: { $exists: true, $ne: null }
+      message_id: { $exists: true, $ne: null, $not: /^pending-/ },
+      createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
     }).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/filesHelper.js

@@ -7,7 +7,7 @@ const sharp = require('sharp');
 
 const { downloadFileFromS3 } = require('../config/awsConfig.js');
 const { Message } = require('../models/messageModel.js');
-const { sanitizeFilename } = require('../utils/sanitizer.js');
+const { sanitizeFilename } = require('../utils/inputSanitizer.js');
 const { logger } = require('../utils/logger');
 
 async function convertPdfToImages(pdfName, existingPdfPath = null) {

package/lib/helpers/mediaHelper.js

@@ -1,7 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const AWS = require('../config/awsConfig.js');
-const { sanitizeMediaFilename } = require('../utils/sanitizer.js');
+const { sanitizeMediaFilename } = require('../utils/inputSanitizer.js');
 const { logger } = require('../utils/logger');
 
 async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, contentType, messageType) {
@@ -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/messageStatusHelper.js

@@ -1,27 +1,28 @@
 const { Message } = require('../models/messageModel');
 const { logger } = require('../utils/logger');
+const { handle24HourWindowError } = require('./templateRecoveryHelper');
 
 /**
  * Update message delivery status in the database based on Twilio status callback data
  */
 async function updateMessageStatus(messageSid, status, errorCode = null, errorMessage = null) {
   try {
-    const statusInfo = {
-      status,
-      updatedAt: new Date()
+    const updateData = {
+      'statusInfo.status': status,
+      'statusInfo.updatedAt': new Date()
     };
 
     if (errorCode) {
-      statusInfo.errorCode = errorCode;
+      updateData['statusInfo.errorCode'] = errorCode;
     }
 
     if (errorMessage) {
-      statusInfo.errorMessage = errorMessage;
+      updateData['statusInfo.errorMessage'] = errorMessage;
     }
 
     const updated = await Message.findOneAndUpdate(
       { message_id: messageSid },
-      { $set: { statusInfo } },
+      { $set: updateData },
       { new: true }
     );
 
@@ -62,12 +63,20 @@ async function handleStatusCallback(twilioStatusData) {
     return null;
   }
 
-  return await updateMessageStatus(
+  const updated = await updateMessageStatus(
     MessageSid,
     MessageStatus.toLowerCase(),
     ErrorCode || null,
     ErrorMessage || null
   );
+
+  if ((ErrorCode === 63016 || ErrorCode === '63016') && updated) {
+    handle24HourWindowError(updated, MessageSid).catch(err => 
+      logger.error('[MessageStatus] Recovery error', { messageSid: MessageSid, error: err.message })
+    );
+  }
+
+  return updated;
 }
 
 /**

package/lib/helpers/processHelper.js

@@ -2,8 +2,7 @@ const fs = require('fs');
 const { generatePresignedUrl } = require('../config/awsConfig.js');
 const { analyzeImage } = require('./llmsHelper.js');
 const { cleanupFiles, downloadMediaAndCreateFile } = require('./filesHelper.js');
-const { formatMessage } = require('./messageHelper.js');
-const { sanitizeLogMetadata } = require('../utils/sanitizer.js');
+const { sanitizeLogMetadata } = require('../utils/inputSanitizer.js');
 const { withTracing } = require('../utils/tracingDecorator.js');
 
 /**
@@ -35,23 +34,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 +116,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/templateRecoveryHelper.js

@@ -0,0 +1,72 @@
+const { logger } = require('../utils/logger');
+const { getDefaultInstance } = require('../core/NexusMessaging');
+const { Template, configureNexusProvider: configureTemplateProvider } = require('../templates/templateStructure');
+const { sendMessage } = require('../core/NexusMessaging');
+const { Message } = require('../models/messageModel');
+
+/**
+ * Handle 24-hour window error by creating template and sending when approved
+ */
+async function handle24HourWindowError(message, messageSid) {
+  try {
+    if (!message?.body || !message?.numero) return;
+
+    const messaging = getDefaultInstance();
+    const provider = messaging?.getProvider();
+    if (!provider?.createTemplate) return;
+
+    configureTemplateProvider(provider);
+
+    const templateName = `auto_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    const template = new Template(templateName, 'UTILITY', 'es');
+    template.setBody(message.body, []);
+    const twilioContent = await template.save();
+
+    // Submit for approval
+    const approvalName = `${templateName}_${Date.now()}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    await provider.submitForApproval(twilioContent.sid, approvalName, 'UTILITY');
+
+    await Message.updateOne(
+      { message_id: messageSid },
+      { $set: { 'statusInfo.recoveryTemplateSid': twilioContent.sid } }
+    );
+
+    logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
+
+    const checkApproval = async (attempt = 0, maxAttempts = 40) => {
+      if (attempt >= maxAttempts) {
+        logger.warn('[TemplateRecovery] Max attempts reached, template not approved yet', { messageSid, templateSid: twilioContent.sid });
+        return;
+      }
+
+      setTimeout(async () => {
+        try {
+          const status = await provider.checkApprovalStatus(twilioContent.sid);
+          const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
+          
+          if (approvalStatus === 'APPROVED') {
+            await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
+            logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
+          } else if (approvalStatus === 'REJECTED') {
+            logger.warn('[TemplateRecovery] Template rejected', { messageSid, templateSid: twilioContent.sid });
+          } else {
+            checkApproval(attempt + 1, maxAttempts);
+          }
+        } catch (err) {
+          logger.error('[TemplateRecovery] Error checking approval', { error: err.message, attempt });
+          // Retry on error (but count as attempt)
+          if (attempt + 1 < maxAttempts) {
+            checkApproval(attempt + 1, maxAttempts);
+          }
+        }
+      }, 15 * 60 * 1000);
+    };
+
+    checkApproval(0);
+
+  } catch (error) {
+    logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });
+  }
+}
+
+module.exports = { handle24HourWindowError };

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');
@@ -24,53 +23,86 @@ function convertTwilioToInternalFormat(twilioMessage) {
 }
 
 
-async function downloadMediaFromTwilio(mediaUrl, logger) {
-  try {
-    const authHeader = `Basic ${Buffer.from(
-      `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
-    ).toString('base64')}`;
-
-    logger.info('[TwilioMedia] Starting download', {
-      url: mediaUrl,
-      hasAccountSid: !!process.env.TWILIO_ACCOUNT_SID,
-      hasAuthToken: !!process.env.TWILIO_AUTH_TOKEN,
-      accountSidLength: process.env.TWILIO_ACCOUNT_SID?.length || 0,
-      authHeaderSample: authHeader.substring(0, 20) + '...'
-    });
-        
-    const response = await axios({
-      method: 'GET',
-      url: mediaUrl,
-      responseType: 'arraybuffer',
-      timeout: 30000,
-      headers: {
-        'Authorization': authHeader
+async function downloadMediaFromTwilio(mediaUrl, logger, maxRetries = 5) {
+  logger.info('[TwilioMedia] Starting download', {
+    url: mediaUrl,
+    maxRetries,
+    hasAccountSid: !!process.env.TWILIO_ACCOUNT_SID,
+    hasAuthToken: !!process.env.TWILIO_AUTH_TOKEN,
+    hasCredentials: !!(process.env.TWILIO_ACCOUNT_SID && process.env.TWILIO_AUTH_TOKEN)
+  });
+
+  const authorization = `Basic ${Buffer.from(
+    `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+  ).toString('base64')}`;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logger.debug('[TwilioMedia] Download attempt', { attempt, maxRetries });
+      
+      const response = await axios.get(mediaUrl, {
+        headers: {
+          'Authorization': authorization,
+          'User-Agent': 'Nexus-Media-Processor/1.0'
+        },
+        responseType: 'arraybuffer',
+        timeout: 30000
+      });
+
+      logger.info('[TwilioMedia] Download successful', {
+        status: response.status,
+        contentType: response.headers['content-type'],
+        contentLength: response.headers['content-length'],
+        dataSize: response.data?.length || 0,
+        attempt
+      });
+
+      return Buffer.from(response.data);
+    } catch (error) {
+      const is404 = error.response?.status === 404;
+      const isLastAttempt = attempt === maxRetries;
+      
+      if (is404 && !isLastAttempt) {
+        const delay = Math.pow(2, attempt - 1) * 1000; // 1s, 2s, 4s
+        logger.info('[TwilioMedia] Media not ready, retrying after delay', {
+          attempt,
+          maxRetries,
+          delayMs: delay,
+          mediaId: mediaUrl.split('/').pop()
+        });
+        await new Promise(resolve => setTimeout(resolve, delay));
+        continue;
       }
-    });
-
-    logger.info('[TwilioMedia] Download successful', {
-      status: response.status,
-      contentType: response.headers['content-type'],
-      contentLength: response.headers['content-length'],
-      dataSize: response.data?.length || 0
-    });
-
-    return Buffer.from(response.data);
-  } catch (error) {
-    logger.error('[TwilioMedia] Download failed', {
-      message: error.message,
-      status: error.response?.status,
-      statusText: error.response?.statusText,
-      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)
-    });
-    throw error;
+      
+      // Check if truly expired (after all retries)
+      const isMediaExpired = is404 && mediaUrl.includes('/Media/');
+      
+      if (isMediaExpired && isLastAttempt) {
+        logger.info('[TwilioMedia] Media expired (24h limit), skipping download', {
+          mediaId: mediaUrl.split('/').pop(),
+          status: 404,
+          attemptsUsed: attempt
+        });
+        return null;
+      }
+      
+      logger.error('[TwilioMedia] Download failed', {
+        message: error.message,
+        status: error.response?.status,
+        statusText: error.response?.statusText,
+        attempt,
+        maxRetries,
+        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)
+      });
+      
+      throw error;
+    }
   }
 }
 
-
 function getMediaTypeFromContentType(contentType) {
   if (contentType.startsWith('image/')) return 'imageMessage';
   if (contentType.startsWith('audio/')) return 'audioMessage';
@@ -89,16 +121,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 +167,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 { getLastNMessages } = require('../helpers/messageHelper');
+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,19 +18,21 @@ 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;
       }
 
-      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) {
-      logger.error('[DefaultConversationManager] Context building failed', {
+      logger.error('[DefaultMemoryManager] Context building failed', {
         threadCode: thread.code,
         error: error.message
       });
@@ -50,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
       });
@@ -63,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: [] };
     }
   }
@@ -119,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;
     }
   }
@@ -198,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/models/messageModel.js

@@ -124,6 +124,9 @@ async function insertMessage(values) {
         updatedAt: values.delivery_status_updated_at || null
       };
     }
+    if (messageData.tools_executed === undefined) {
+      messageData.tools_executed = [];
+    }
 
     await Message.findOneAndUpdate(
       { message_id: values.message_id, body: values.body },

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,
+        lastContext: context[-1] || 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 || ''
+        last_symptoms: clinicalData.lastSymptoms || '',
+        current_date: getCurrentMexicoDateTime(),
       } : null;
 
       // Execute with built context
@@ -287,10 +295,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/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/routes/index.js

@@ -39,6 +39,8 @@ const messageRouteDefinitions = {
   'GET /last': 'getLastInteractionController',
   'GET /scheduled-status': 'checkScheduledMessageStatusController',
   'GET /status': 'checkMessageStatusController',
+  'GET /status/:messageSid': 'getMessageStatusController',
+  'POST /status-callback': 'messageStatusCallbackController',
   'POST /quality': 'addQualityVoteController',
   'GET /quality/:message_id': 'getQualityVotesByMessageController',
   'GET /quality/:message_id/voter/:voter_username': 'getQualityVoteByMessageAndVoterController',
@@ -97,6 +99,7 @@ const conversationController = require('../controllers/conversationController');
 const interactionController = require('../controllers/interactionController');
 const mediaController = require('../controllers/mediaController');
 const messageController = require('../controllers/messageController');
+const messageStatusController = require('../controllers/messageStatusController');
 const patientController = require('../controllers/patientController');
 const qualityMessageController = require('../controllers/qualityMessageController');
 const templateController = require('../controllers/templateController');
@@ -144,6 +147,8 @@ const builtInControllers = {
   getLastInteractionController: messageController.getLastInteractionController,
   checkScheduledMessageStatusController: messageController.checkScheduledMessageStatusController,
   checkMessageStatusController: messageController.checkMessageStatusController,
+  getMessageStatusController: messageStatusController.getMessageStatusController,
+  messageStatusCallbackController: messageStatusController.messageStatusCallbackController,
   addQualityVoteController: qualityMessageController.addQualityVoteController,
   getQualityVotesByMessageController: qualityMessageController.getQualityVotesByMessageController,
   getQualityVoteByMessageAndVoterController: qualityMessageController.getQualityVoteByMessageAndVoterController,

package/lib/services/assistantServiceCore.js

@@ -10,10 +10,12 @@ 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');
+const { sanitizeOutput } = require('../utils/outputSanitizer');
 
 const createAssistantCore = async (code, assistant_id, messages = [], force = false) => {
   const findThread = await Thread.findOne({ code: code });
@@ -156,18 +158,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 +188,17 @@ 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
+          .filter(msg => msg.content.text !== r.reply?.body)
+          .map(msg => msg.content.text)
+          .join(' ')
+        : null;
+      return updateMessageRecord(r.reply, finalThread, processedContent);
+    }));
     await cleanupFiles(allTempFiles);
 
     if (urls.length > 0) {
@@ -217,15 +226,24 @@ 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;
     
-    const { output, completed, retries, predictionTimeMs, tools_executed } = runResult;
+    const { output: rawOutput, completed, retries, predictionTimeMs, tools_executed } = runResult;
+    
+    const output = sanitizeOutput(rawOutput);
+    if (rawOutput !== output) {
+      logger.debug('[replyAssistantCore] Output sanitized', {
+        originalLength: rawOutput?.length || 0,
+        sanitizedLength: output?.length || 0,
+        removedContent: rawOutput?.length ? 'brackets_removed' : 'none'
+      });
+    }
 
     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/services/conversationService.js

@@ -21,19 +21,9 @@ const fetchConversationData = async (filter, skip, limit) => {
   
   const pipeline = [
     { $match: filterConditions },
-    { $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 } 
-    } },
+    { $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 } } },
     { $match: { _id: { $nin: [null, ''] } } },
     ...(filter === 'no-response' ? [{ $match: { 'latestMessage.from_me': false } }] : []),
     {

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/outputSanitizer.js

@@ -0,0 +1,23 @@
+/**
+ * Sanitize AI response output by removing unwanted content
+ */
+
+function removeBracketContent(text) {
+  if (!text || typeof text !== 'string') return text;  
+  return text.replace(/\[([^\]]*)\]/g, '').trim();
+}
+
+function sanitizeOutput(text) {
+  if (!text || typeof text !== 'string') return text;
+  
+  let sanitized = text;
+  sanitized = removeBracketContent(sanitized);
+  sanitized = sanitized.replace(/\s+/g, ' ').trim();
+  
+  return sanitized;
+}
+
+module.exports = {
+  sanitizeOutput,
+  removeBracketContent
+};

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": "2.7.1",
+  "version": "2.8.0",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -107,7 +107,7 @@
     "baileys": "^6.4.0",
     "express": "^4.22.1",
     "openai": "6.7.0",
-    "twilio": "5.6.0"
+    "twilio": "5.11.2"
   },
   "engines": {
     "node": ">=20.0.0"