@peopl-health/nexus 2.5.0 → 2.5.1

package/lib/adapters/TwilioProvider.js

@@ -154,6 +154,41 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
+  async sendTypingIndicator(messageId) {
+    try {      
+      const response = await axios.post(
+        'https://messaging.twilio.com/v2/Indicators/Typing.json',
+        new URLSearchParams({
+          messageId: messageId,
+          channel: 'whatsapp'
+        }),
+        {
+          auth: {
+            username: this.accountSid,
+            password: this.authToken
+          },
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        }
+      );
+      logger.info('[TwilioProvider] Typing indicator sent successfully', { 
+        messageId, 
+        success: response.data?.success,
+        status: response.status 
+      });
+      return { success: true };
+    } catch (error) {
+      logger.error('[TwilioProvider] Failed to send typing indicator', { 
+        error: error.message, 
+        messageId,
+        status: error.response?.status,
+        data: error.response?.data
+      });
+      return { success: false };
+    }
+  }
+
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
     const delay = this.calculateDelay(sendTime, timeZone);

package/lib/core/NexusMessaging.js

@@ -42,8 +42,7 @@ class NexusMessaging {
     this.pendingResponses = new Map();
     this.batchingConfig = {
       enabled: config.messageBatching?.enabled ?? false,
-      baseWaitTime: config.messageBatching?.baseWaitTime ?? 15000,
-      randomVariation: config.messageBatching?.randomVariation ?? 5000
+      baseWaitTime: config.messageBatching?.baseWaitTime ?? 15000
     };
   }
 
@@ -373,6 +372,22 @@ class NexusMessaging {
     } else if (messageData.flow) {
       return await this.handleFlow(messageData);
     } else {
+      if (chatId && this.provider && typeof this.provider.sendTypingIndicator === 'function') {
+        const messageId = messageData.id || messageData.MessageSid || messageData.message_id;        
+        if (messageId) {
+          this.provider.sendTypingIndicator(messageId)
+            .then(() => logger.debug('[processIncomingMessage] Typing indicator sent successfully', { messageId }))
+            .catch(err => logger.warn('[processIncomingMessage] Typing indicator failed', { 
+              error: err.message, 
+              messageId 
+            }));
+        } else {
+          logger.warn('[processIncomingMessage] No message ID found for typing indicator', { 
+            messageData: JSON.stringify(messageData).substring(0, 200) 
+          });
+        }
+      }
+      
       // For regular messages and media, use batching if enabled
       logger.info('Batching config:', this.batchingConfig);
       if (this.batchingConfig.enabled && chatId) {
@@ -635,17 +650,12 @@ class NexusMessaging {
    * Handle message with batching - waits for additional messages before processing
    */
   async _handleWithBatching(messageData, chatId) {
-    // Clear existing timeout if there is one
     if (this.pendingResponses.has(chatId)) {
       clearTimeout(this.pendingResponses.get(chatId));
       logger.info(`Received additional message from ${chatId}, resetting wait timer`);
     }
-    
-    // Calculate wait time with random variation
-    const waitTime = this.batchingConfig.baseWaitTime + 
-      Math.floor(Math.random() * this.batchingConfig.randomVariation);
-    
-    // Set new timeout
+
+    const waitTime = this.batchingConfig.baseWaitTime;
     const timeoutId = setTimeout(async () => {
       try {
         this.pendingResponses.delete(chatId);
@@ -685,7 +695,7 @@ class NexusMessaging {
       this.events.emit('messages:batched', { chatId, response: botResponse });
       
     } catch (error) {
-      logger.error('Error in batched message handling:', error);
+      logger.error('Error in batched message handling:', { error: error.message });
     }
   }
 

package/lib/services/assistantService.js

@@ -5,6 +5,7 @@ const runtimeConfig = require('../config/runtimeConfig');
 const { BaseAssistant } = require('../assistants/BaseAssistant');
 const { createProvider } = require('../providers/createProvider');
 
+const { Message } = require('../models/messageModel.js');
 const { Thread } = require('../models/threadModel.js');
 const { PredictionMetrics } = require('../models/predictionMetricsModel');
 const { insertMessage } = require('../models/messageModel');
@@ -328,161 +329,188 @@ const addInsAssistant = withTracing(
   })
 );
 
+const startTypingIndicator = async (provider, code) => {
+  try {
+    const lastMessage = await Message.findOne({ 
+      numero: code, 
+      from_me: false,
+      message_id: { $exists: true, $ne: null }
+    }).sort({ createdAt: -1 });
+    
+    if (!lastMessage?.message_id) return null;
+    
+    return setInterval(() => 
+      provider.sendTypingIndicator(lastMessage.message_id).catch(err => 
+        logger.debug('[startTypingIndicator] Interval failed', { error: err.message })
+      ), 25000
+    );
+  } catch (err) {
+    logger.debug('[startTypingIndicator] Failed to start', { error: err.message });
+    return null;
+  }
+};
+
 const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}) => {
   const timings = {};
   const startTotal = Date.now();
   
-  const { result: thread, duration: getThreadMs } = await withTracing(
-    getThread, 
-    'get_thread_operation', 
-    (threadCode) => ({ 
-      'thread.code': threadCode,
-      'operation.type': 'thread_retrieval',
-      'thread.provided': !!thread_
-    }),
-    { returnTiming: true }
-  )(code);
-  timings.get_thread_ms = getThreadMs;
-  
-  if (!thread_ && !thread) return null;
-  const finalThread = thread_ || thread;
-
-  const { result: patientReply, duration: getMessagesMs } = await withTracing(
-    getLastMessages,
-    'get_last_messages',
-    (code) => ({ 'thread.code': code }),
-    { returnTiming: true }
-  )(code);
-  timings.get_messages_ms = getMessagesMs;
-  
-  if (!patientReply) {
-    logger.info('[replyAssistantCore] No relevant data found for this assistant.');
-    return null;
-  }
-
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+  const typingInterval = await startTypingIndicator(provider, code);
   
-  logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
-  
-  const { result: processResult, duration: processMessagesMs } = await withTracing(
-    processThreadMessage,
-    'process_thread_messages',
-    (code, patientReply, provider) => ({
-      'messages.count': patientReply.length,
-      'thread.code': code
-    }),
-    { returnTiming: true }
-  )(code, patientReply, provider);
-  
-  const { results: processResults, timings: processTimings } = processResult;
-  timings.process_messages_ms = processMessagesMs;
-  
-  logger.debug('[replyAssistantCore] Process timings breakdown', { processTimings });
-  
-  if (processTimings) {
-    timings.process_messages_breakdown = {
-      download_ms: processTimings.download_ms || 0,
-      image_analysis_ms: processTimings.image_analysis_ms || 0,
-      audio_transcription_ms: processTimings.audio_transcription_ms || 0,
-      url_generation_ms: processTimings.url_generation_ms || 0,
-      total_media_ms: processTimings.total_media_ms || 0
-    };
-  }
-  
-  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 || []);
-  
-  if (allMessagesToAdd.length > 0) {
-    logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-    await withThreadRecovery(
-      async (thread = finalThread) => {
-        const threadId = thread.getConversationId();
-        await provider.addMessage({ threadId, messages: allMessagesToAdd });
-      },
-      finalThread,
-      process.env.VARIANT || 'assistants'
-    );
-  }
-  
-  await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
-  await cleanupFiles(allTempFiles);
+  try {
+    const { result: thread, duration: getThreadMs } = await withTracing(
+      getThread, 
+      'get_thread_operation', 
+      (threadCode) => ({ 
+        'thread.code': threadCode,
+        'operation.type': 'thread_retrieval',
+        'thread.provided': !!thread_
+      }),
+      { returnTiming: true }
+    )(code);
+    timings.get_thread_ms = getThreadMs;
+    
+    if (!thread_ && !thread) return null;
+    const finalThread = thread_ || thread;
+
+    const { result: patientReply, duration: getMessagesMs } = await withTracing(
+      getLastMessages,
+      'get_last_messages',
+      (code) => ({ 'thread.code': code }),
+      { returnTiming: true }
+    )(code);
+    timings.get_messages_ms = getMessagesMs;
+    
+    if (!patientReply) {
+      logger.info('[replyAssistantCore] No relevant data found for this assistant.');
+      return null;
+    }
   
-  if (urls.length > 0) {
-    logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
-    const { result: pdfResult, duration: pdfCombinationMs } = await withTracing(
-      combineImagesToPDF,
-      'combine_images_to_pdf',
-      ({ code }) => ({
-        'pdf.thread_code': code,
-        'pdf.url_count': urls.length
+    logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+    const { result: processResult, duration: processMessagesMs } = await withTracing(
+      processThreadMessage,
+      'process_thread_messages',
+      (code, patientReply, provider) => ({
+        'messages.count': patientReply.length,
+        'thread.code': code
       }),
       { returnTiming: true }
-    )({ code });
-    timings.pdf_combination_ms = pdfCombinationMs;
-    const { pdfBuffer, processedFiles } = pdfResult;
-    logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+    )(code, patientReply, provider);
     
-    if (pdfBuffer) {
-      const key = `${code}-${Date.now()}-combined.pdf`;
-      const bucket = runtimeConfig.get('AWS_S3_BUCKET_NAME');
-      if (bucket) {
-        await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
-      }
+    const { results: processResults, timings: processTimings } = processResult;
+    timings.process_messages_ms = processMessagesMs;
+    
+    logger.debug('[replyAssistantCore] Process timings breakdown', { processTimings });
+  
+    if (processTimings) {
+      timings.process_messages_breakdown = {
+        download_ms: processTimings.download_ms || 0,
+        image_analysis_ms: processTimings.image_analysis_ms || 0,
+        audio_transcription_ms: processTimings.audio_transcription_ms || 0,
+        url_generation_ms: processTimings.url_generation_ms || 0,
+        total_media_ms: processTimings.total_media_ms || 0
+      };
     }
+  
+    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 || []);
     
-    if (processedFiles && processedFiles.length) {
-      cleanupFiles(processedFiles);
+    if (allMessagesToAdd.length > 0) {
+      logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
+      await withThreadRecovery(
+        async (thread = finalThread) => {
+          const threadId = thread.getConversationId();
+          await provider.addMessage({ threadId, messages: allMessagesToAdd });
+        },
+        finalThread,
+        process.env.VARIANT || 'assistants'
+      );
+    }
+  
+    await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
+    await cleanupFiles(allTempFiles);
+  
+    if (urls.length > 0) {
+      logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+      const { result: pdfResult, duration: pdfCombinationMs } = await withTracing(
+        combineImagesToPDF,
+        'combine_images_to_pdf',
+        ({ code }) => ({
+          'pdf.thread_code': code,
+          'pdf.url_count': urls.length
+        }),
+        { returnTiming: true }
+      )({ code });
+      timings.pdf_combination_ms = pdfCombinationMs;
+      const { pdfBuffer, processedFiles } = pdfResult;
+      logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+      
+      if (pdfBuffer) {
+        const key = `${code}-${Date.now()}-combined.pdf`;
+        const bucket = runtimeConfig.get('AWS_S3_BUCKET_NAME');
+        if (bucket) {
+          await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
+        }
+      }
+      
+      if (processedFiles && processedFiles.length) {
+        cleanupFiles(processedFiles);
+      }
     }
-  }
 
-  if (!patientMsg || finalThread.stopped) return null;
+    if (!patientMsg || finalThread.stopped) return null;
 
-  const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
-  const { result: runResult, duration: runAssistantMs } = await withTracing(
-    runAssistantWithRetries,
-    'run_assistant_with_retries',
-    (thread, assistant, runConfig, patientReply) => ({
-      'assistant.id': thread.getAssistantId(),
-      'assistant.max_retries': DEFAULT_MAX_RETRIES,
-      'assistant.has_patient_reply': !!patientReply
-    }),
-    { returnTiming: true }
-  )(finalThread, assistant, runOptions, patientReply);
-  timings.run_assistant_ms = runAssistantMs;
-  timings.total_ms = Date.now() - startTotal;
-  
-  const { run, output, completed, retries, predictionTimeMs, tools_executed } = runResult;
-
-  logger.info('[Assistant Reply Complete]', {
-    code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-    messageCount: patientReply.length,
-    hasMedia: urls.length > 0,
-    retries,
-    totalMs: timings.total_ms,
-    toolsExecuted: tools_executed?.length || 0
-  });
-
-  if (output && predictionTimeMs) {
-    logger.debug('[replyAssistantCore] Storing metrics with timing_breakdown', { 
-      timing_breakdown: timings,
-      has_breakdown: !!timings.process_messages_breakdown
-    });
+    const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
+    const { result: runResult, duration: runAssistantMs } = await withTracing(
+      runAssistantWithRetries,
+      'run_assistant_with_retries',
+      (thread, assistant, runConfig, patientReply) => ({
+        'assistant.id': thread.getAssistantId(),
+        'assistant.max_retries': DEFAULT_MAX_RETRIES,
+        'assistant.has_patient_reply': !!patientReply
+      }),
+      { returnTiming: true }
+    )(finalThread, assistant, runOptions, patientReply);
+    timings.run_assistant_ms = runAssistantMs;
+    timings.total_ms = Date.now() - startTotal;
     
-    await PredictionMetrics.create({
-      message_id: `${code}-${Date.now()}`,
-      numero: code,
-      assistant_id: finalThread.getAssistantId(),
-      thread_id: finalThread.getConversationId(),
-      prediction_time_ms: predictionTimeMs,
-      retry_count: retries,
-      completed: completed,
-      timing_breakdown: timings
-    }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
-  }
+    const { run, output, completed, retries, predictionTimeMs, tools_executed } = runResult;
+
+    logger.info('[Assistant Reply Complete]', {
+      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+      messageCount: patientReply.length,
+      hasMedia: urls.length > 0,
+      retries,
+      totalMs: timings.total_ms,
+      toolsExecuted: tools_executed?.length || 0
+    });
+
+    if (output && predictionTimeMs) {
+      logger.debug('[replyAssistantCore] Storing metrics with timing_breakdown', { 
+        timing_breakdown: timings,
+        has_breakdown: !!timings.process_messages_breakdown
+      });
+      
+      await PredictionMetrics.create({
+        message_id: `${code}-${Date.now()}`,
+        numero: code,
+        assistant_id: finalThread.getAssistantId(),
+        thread_id: finalThread.getConversationId(),
+        prediction_time_ms: predictionTimeMs,
+        retry_count: retries,
+        completed: completed,
+        timing_breakdown: timings
+      }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
+    }
 
-  return { output, tools_executed };
+    return { output, tools_executed };
+  } finally {
+    if (typingInterval) {
+      clearInterval(typingInterval);
+    }
+  }
 };
 
 const replyAssistant = withTracing(

package/package.json

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