@peopl-health/nexus 2.7.0 → 2.8.0-fix.1

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

@@ -73,6 +73,18 @@ const messageSchema = new mongoose.Schema({
     errorCode: { type: String, default: null },
     errorMessage: { type: String, default: null },
     updatedAt: { type: Date, default: null }
+  },
+  recoveryInfo: {
+    status: {
+      type: String,
+      enum: ['in_progress', 'completed', 'failed', 'cancelled', null],
+      default: null
+    },
+    templateSid: { type: String, default: null },
+    lastCheckedAt: { type: Date, default: null },
+    startedAt: { type: Date, default: null },
+    completedAt: { type: Date, default: null },
+    error: { type: String, default: null }
   }
 }, { timestamps: true });
 
@@ -124,6 +136,13 @@ async function insertMessage(values) {
         updatedAt: values.delivery_status_updated_at || null
       };
     }
+    if (messageData.tools_executed === undefined) {
+      messageData.tools_executed = [];
+    }
+
+    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/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
+};