@peopl-health/nexus 2.4.11 → 2.4.12

package/lib/adapters/TwilioProvider.js

@@ -118,7 +118,7 @@ class TwilioProvider extends MessageProvider {
             provider: 'twilio',
             timestamp: new Date(),
             fromMe: true,
-            processed: false
+            processed: messageData.processed !== undefined ? messageData.processed : false
           });
           logger.info('[TwilioProvider] Message persisted successfully', { messageId: result.sid });
         } catch (storageError) {

package/lib/controllers/assistantController.js

@@ -29,7 +29,7 @@ const addInsAssistantController = async (req, res) => {
     const role = variant === 'responses' ? 'developer' : 'user';
     
     const ans = await addInsAssistant(code, instruction, role);
-    if (ans) await sendMessage({code, body: ans, fileType: 'text'});
+    if (ans) await sendMessage({code, body: ans, fileType: 'text', origin: 'assistant'});
     return res.status(200).send({ message: 'Add instruction to the assistant' });
   } catch (error) {
     logger.error(error);
@@ -42,7 +42,7 @@ const addMsgAssistantController = async (req, res) => {
 
   try {
     const ans = await addMsgAssistant(code, messages, role, reply);
-    if (ans) await sendMessage({code, body: ans, fileType: 'text'});
+    if (ans) await sendMessage({code, body: ans, fileType: 'text', origin: 'assistant'});
     return res.status(200).send({ message: 'Add message to the assistant' });
   } catch (error) {
     logger.error(error);

package/lib/controllers/conversationController.js

@@ -232,7 +232,8 @@ const getConversationReplyController = async (req, res) => {
     
     const messageData = {
       code: formattedPhoneNumber,
-      fileType: 'text'
+      fileType: 'text',
+      _fromConversationReply: true
     };
     
     // Handle template message (contentSid provided)

package/lib/core/NexusMessaging.js

@@ -279,6 +279,10 @@ class NexusMessaging {
       throw new Error('No provider initialized');
     }
 
+    if (messageData._fromConversationReply && messageData.code && (messageData.body || messageData.message || messageData.contentSid)) {
+      messageData.processed = true;
+    }
+
     const result = await this.provider.sendMessage(messageData);
 
     // Store message only if provider does not handle persistence itself
@@ -297,14 +301,24 @@ class NexusMessaging {
       });
     }
 
-    // Add to thread context for manual sends
-    if (messageData.origin !== 'assistant' && messageData.code && 
-      (messageData.body || messageData.message)) {
+    // Add to thread context for manual sends (text messages and templates)
+    let messageContent = messageData.body || messageData.message;
+    if (!messageContent && messageData.contentSid && typeof this.provider.renderTemplate === 'function') {
+      try {
+        messageContent = await this.provider.renderTemplate(messageData.contentSid, messageData.variables);
+      } catch (err) {
+        logger.warn(`[NexusMessaging] Failed to render template for thread: ${err.message}`);
+      }
+    }
+    
+    if (messageData.origin !== 'assistant' && messageData.code && messageContent) {
+      const skipSystemMessage = messageData._fromConversationReply === true;
       await addMsgAssistant(
         messageData.code,
-        [messageData.body || messageData.message],
+        [messageContent],
         'assistant',
-        false
+        false,
+        skipSystemMessage
       );
     }
 

package/lib/helpers/processHelper.js

@@ -4,6 +4,7 @@ const { analyzeImage } = require('./llmsHelper.js');
 const { cleanupFiles, downloadMediaAndCreateFile } = require('./filesHelper.js');
 const { formatMessage } = require('./messageHelper.js');
 const { sanitizeLogMetadata } = require('../utils/sanitizer.js');
+const { withTracing } = require('../utils/tracingDecorator.js');
 
 /**
  * Structured logging with PHI protection
@@ -56,35 +57,41 @@ const processTextMessage = (reply) => {
   return messagesChat;
 };
 
-const processImageFile = async (fileName, reply) => {
+const processImageFileCore = async (fileName, reply) => {
   let imageAnalysis = null;
   let url = null;
   const messagesChat = [];
+  const timings = {
+    analysis_ms: 0,
+    url_generation_ms: 0
+  };
 
   const isSticker = reply.media?.mediaType === 'sticker' || 
                     fileName.toLowerCase().includes('sticker/') ||
                     fileName.toLowerCase().includes('/sticker/');
 
   try {
-    imageAnalysis = await analyzeImage(fileName, isSticker, reply.media?.contentType);
-    
-    logger.info('processImageFile', {
-      message_id: reply.message_id,
-      bucketName: reply.media?.bucketName,
-      key: reply.media?.key,
-      is_sticker: isSticker,
-      medical_relevance: imageAnalysis?.medical_relevance,
-      has_table: imageAnalysis?.has_table,
-      analysis_type: imageAnalysis?.medical_analysis ? 'medical' : 'general'
-    });
-    
-    logger.debug('processImageFile_analysis', { imageAnalysis });
+    const { result: analysis, duration: analysisDuration } = await withTracing(
+      analyzeImage,
+      'analyze_image',
+      () => ({ 'image.is_sticker': isSticker, 'image.message_id': reply.message_id }),
+      { returnTiming: true }
+    )(fileName, isSticker, reply.media?.contentType);
+    imageAnalysis = analysis;
+    timings.analysis_ms = analysisDuration;
     
     const invalidAnalysis = ['NOT_MEDICAL', 'QUALITY_INSUFFICIENT'];
     
     // Generate presigned URL only if medically relevant AND not a sticker
     if (imageAnalysis?.medical_relevance && !isSticker) {
-      url = await generatePresignedUrl(reply.media.bucketName, reply.media.key);            
+      const { result: presignedUrl, duration: urlDuration } = await withTracing(
+        generatePresignedUrl,
+        'generate_presigned_url',
+        () => ({ 'url.bucket': reply.media.bucketName }),
+        { returnTiming: true }
+      )(reply.media.bucketName, reply.media.key);
+      url = presignedUrl;
+      timings.url_generation_ms = urlDuration;
     }
     
     // Add appropriate text based on analysis
@@ -104,6 +111,18 @@ const processImageFile = async (fileName, reply) => {
         text: imageAnalysis?.description || 'Image processed',
       });
     }
+    
+    logger.info('processImageFile', {
+      message_id: reply.message_id,
+      is_sticker: isSticker,
+      medical_relevance: imageAnalysis?.medical_relevance,
+      has_table: imageAnalysis?.has_table,
+      analysis_type: imageAnalysis?.medical_analysis ? 'medical' : 'general',
+      ...timings
+    });
+    
+    logger.debug('processImageFile_analysis', { imageAnalysis });
+    
   } catch (error) {
     logger.error('processImageFile', error, {
       message_id: reply.message_id,
@@ -116,18 +135,36 @@ const processImageFile = async (fileName, reply) => {
     });
   }
 
-  return { messagesChat, url };
+  return { messagesChat, url, timings };
 };
 
-const processAudioFile = async (fileName, provider) => {
+const processImageFile = withTracing(
+  processImageFileCore,
+  'process_image_file',
+  (fileName, reply) => ({
+    'image.message_id': reply.message_id,
+    'image.has_media': !!reply.media
+  })
+);
+
+const processAudioFileCore = async (fileName, provider) => {
   const messagesChat = [];
+  const timings = {
+    transcribe_ms: 0
+  };
   
   try {
-    const audioTranscript = await provider.transcribeAudio({
-      file: fs.createReadStream(fileName),
-      responseFormat: 'text',
-      language: 'es'
-    });
+    const { result: audioTranscript, duration: transcribeDuration } = await withTracing(
+      async () => provider.transcribeAudio({
+        file: fs.createReadStream(fileName),
+        responseFormat: 'text',
+        language: 'es'
+      }),
+      'transcribe_audio',
+      () => ({ 'audio.file_name': fileName ? fileName.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown' }),
+      { returnTiming: true }
+    )();
+    timings.transcribe_ms = transcribeDuration;
     
     const transcriptText = audioTranscript?.text || audioTranscript;
     messagesChat.push({
@@ -138,7 +175,8 @@ const processAudioFile = async (fileName, provider) => {
     logger.info('processAudioFile', {
       fileName: fileName ? fileName.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown',
       transcription_success: true,
-      transcript_length: transcriptText?.length || 0
+      transcript_length: transcriptText?.length || 0,
+      ...timings
     });
     
     logger.debug('processAudioFile_transcript', { transcriptText });
@@ -153,34 +191,44 @@ const processAudioFile = async (fileName, provider) => {
     });
   }
 
-  return messagesChat;
+  return { messagesChat, timings };
 };
 
-const processMediaFiles = async (code, reply, provider) => {
+const processAudioFile = withTracing(
+  processAudioFileCore,
+  'process_audio_file',
+  (fileName) => ({
+    'audio.file_name': fileName ? fileName.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown'
+  })
+);
+
+const processMediaFilesCore = async (code, reply, provider) => {
   let url = null;
   const messagesChat = [];
   const tempFiles = [];
+  const timings = {
+    download_ms: 0,
+    image_analysis_ms: 0,
+    audio_transcription_ms: 0,
+    url_generation_ms: 0
+  };
 
   if (!reply.is_media) {
-    return { messagesChat, url, tempFiles };
+    return { messagesChat, url, tempFiles, timings };
   }
 
-  logger.info('processMediaFiles', {
-    message_id: reply.message_id,
-    processing_media: true
-  });
-  
-  const fileNames = await downloadMediaAndCreateFile(code, reply);
+  const { result: fileNames, duration: downloadDuration } = await withTracing(
+    downloadMediaAndCreateFile,
+    'download_media',
+    () => ({ 'media.message_id': reply.message_id, 'media.type': reply.media?.mediaType }),
+    { returnTiming: true }
+  )(code, reply);
+  timings.download_ms = downloadDuration;
   tempFiles.push(...fileNames);
 
   for (const fileName of fileNames) {
     const safeFileName = fileName ? fileName.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown';
     
-    logger.info('processMediaFiles_file', {
-      message_id: reply.message_id,
-      fileName: safeFileName
-    });
-    
     // Skip only WBMP files (unsupported format)
     if (fileName.toLowerCase().includes('.wbmp')) {
       logger.info('processMediaFiles_skip', {
@@ -200,34 +248,75 @@ const processMediaFiles = async (code, reply, provider) => {
                         fileName.toLowerCase().includes('/sticker/');
 
     if (isImageLike) {
-      const { messagesChat: imageMessages, url: imageUrl } = await processImageFile(fileName, reply);
+      const { messagesChat: imageMessages, url: imageUrl, timings: imageTimings } = await processImageFile(fileName, reply);
+      
       messagesChat.push(...imageMessages);
       if (imageUrl) url = imageUrl;
+      
+      if (imageTimings) {
+        timings.image_analysis_ms += imageTimings.analysis_ms || 0;
+        timings.url_generation_ms += imageTimings.url_generation_ms || 0;
+      }
     } else if (fileName.includes('audio')) {
-      const audioMessages = await processAudioFile(fileName, provider);
+      const { messagesChat: audioMessages, timings: audioTimings } = await processAudioFile(fileName, provider);
+      
       messagesChat.push(...audioMessages);
+      
+      if (audioTimings) {
+        timings.audio_transcription_ms += audioTimings.transcribe_ms || 0;
+      }
     }
   }
 
-  return { messagesChat, url, tempFiles };
+  logger.info('processMediaFiles_complete', {
+    message_id: reply.message_id,
+    file_count: fileNames.length,
+    ...timings
+  });
+
+  return { messagesChat, url, tempFiles, timings };
 };
 
-const processThreadMessage = async (code, replies, provider) => {
+const processMediaFiles = withTracing(
+  processMediaFilesCore,
+  'process_media_files',
+  (code, reply) => ({
+    'media.message_id': reply.message_id,
+    'media.is_media': reply.is_media
+  })
+);
+
+const processThreadMessageCore = async (code, replies, provider) => {
   const replyArray = Array.isArray(replies) ? replies : [replies];
+  const timings = {
+    download_ms: 0,
+    image_analysis_ms: 0,
+    audio_transcription_ms: 0,
+    url_generation_ms: 0,
+    total_media_ms: 0
+  };
   
   const results = await Promise.all(
     replyArray.map(async (reply, i) => {
       let tempFiles = [];
+      
       try {
         const isPatient = reply.origin === 'patient';
-        const [textMessages, mediaResult] = await Promise.all([
-          Promise.resolve(processTextMessage(reply)),
-          processMediaFiles(code, reply, provider)
-        ]);
         
-        const { messagesChat: mediaMessages, url, tempFiles: mediaFiles } = mediaResult;
+        const textMessages = processTextMessage(reply);
+        const mediaResult = await processMediaFiles(code, reply, provider);
+        
+        const { messagesChat: mediaMessages, url, tempFiles: mediaFiles, timings: mediaTimings } = mediaResult;
         tempFiles = mediaFiles;
         
+        if (mediaTimings) {
+          timings.download_ms += mediaTimings.download_ms || 0;
+          timings.image_analysis_ms += mediaTimings.image_analysis_ms || 0;
+          timings.audio_transcription_ms += mediaTimings.audio_transcription_ms || 0;
+          timings.url_generation_ms += mediaTimings.url_generation_ms || 0;
+          timings.total_media_ms += (mediaTimings.download_ms + mediaTimings.image_analysis_ms + mediaTimings.audio_transcription_ms + mediaTimings.url_generation_ms);
+        }
+        
         const allMessages = [...textMessages, ...mediaMessages];
         const role = reply.origin === 'patient' ? 'user' : 'assistant';
         const messages = allMessages.map(content => ({ role, content }));
@@ -235,22 +324,40 @@ const processThreadMessage = async (code, replies, provider) => {
         logger.info('processThreadMessage', { 
           index: i + 1, 
           total: replyArray.length,
-          isPatient, 
-          hasUrl: !!url 
+          isPatient,
+          hasMedia: reply.is_media,
+          hasUrl: !!url
         });
         
         return { isPatient, url, messages, reply, tempFiles };
       } catch (error) {
-        logger.error('processThreadMessage', error, { message_id: reply.message_id, origin: reply.origin });
+        logger.error('processThreadMessage', error, { 
+          message_id: reply.message_id, 
+          origin: reply.origin
+        });
         await cleanupFiles(tempFiles);
         return { isPatient: false, url: null, messages: [], reply, tempFiles: [] };
       }
     })
   );
   
-  return results;
+  logger.info('processThreadMessage_complete', {
+    message_count: replyArray.length,
+    ...timings
+  });
+  
+  return { results, timings };
 };
 
+const processThreadMessage = withTracing(
+  processThreadMessageCore,
+  'process_thread_messages',
+  (code, replies) => ({
+    'messages.count': Array.isArray(replies) ? replies.length : 1,
+    'thread.code': code
+  })
+);
+
 module.exports = {
   processTextMessage,
   processImageFile,

package/lib/models/messageModel.js

@@ -30,7 +30,7 @@ const messageSchema = new mongoose.Schema({
   from_me: { type: Boolean, default: false },
   origin: { 
     type: String, 
-    enum: ['whatsapp_platform', 'assistant', 'patient'], 
+    enum: ['whatsapp_platform', 'assistant', 'patient', 'system', 'instruction'], 
     default: 'whatsapp_platform' },
   tools_executed: [{
     tool_name: { type: String, required: true },

package/lib/services/assistantService.js

@@ -7,6 +7,7 @@ const { createProvider } = require('../providers/createProvider');
 
 const { Thread } = require('../models/threadModel.js');
 const { PredictionMetrics } = require('../models/predictionMetricsModel');
+const { insertMessage } = require('../models/messageModel');
 
 const { getCurRow } = require('../helpers/assistantHelper.js');
 const { runAssistantAndWait, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
@@ -186,7 +187,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   return thread;
 };
 
-const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) => {
+const addMsgAssistant = async (code, inMessages, role = 'user', reply = false, skipSystemMessage = false) => {
   try {
     let thread = await Thread.findOne({ code: code });
     logger.info(thread);
@@ -204,6 +205,32 @@ const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) =
             role: role,
             content: message
           });
+          
+          // Save system message to database for frontend visibility
+          // Skip if message is already saved (e.g., from getConversationReplyController)
+          if (!skipSystemMessage) {
+            try {
+              const message_id = `system_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+              await insertMessage({
+                nombre_whatsapp: 'System',
+                numero: code,
+                body: message,
+                timestamp: new Date(),
+                message_id: message_id,
+                is_group: false,
+                is_media: false,
+                from_me: true,
+                processed: true,
+                origin: 'system',
+                thread_id: thread.getConversationId(),
+                assistant_id: thread.getAssistantId(),
+                raw: { role: role }
+              });
+            } catch (err) {
+              // Don't throw - we don't want to break the flow if logging fails
+              logger.error('[addMsgAssistant] Error saving system message:', err);
+            }
+          }
         }
       },
       thread,
@@ -263,6 +290,29 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
     null // no patientReply for instructions
   );
 
+  // Save instruction to database for frontend visibility
+  try {
+    const message_id = `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    await insertMessage({
+      nombre_whatsapp: 'Instruction',
+      numero: code,
+      body: instruction,
+      timestamp: new Date(),
+      message_id: message_id,
+      is_group: false,
+      is_media: false,
+      from_me: true,
+      processed: true,
+      origin: 'instruction',
+      thread_id: thread.getConversationId(),
+      assistant_id: thread.getAssistantId(),
+      raw: { role: role }
+    });
+  } catch (err) {
+    // Don't throw - we don't want to break the flow if logging fails
+    logger.error('[addInstructionCore] Error saving instruction message:', err);
+  }
+
   logger.info('RUN RESPONSE', output);
   return output;
 };
@@ -314,7 +364,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   
   logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
   
-  const { result: processResults, duration: processMessagesMs } = await withTracing(
+  const { result: processResult, duration: processMessagesMs } = await withTracing(
     processThreadMessage,
     'process_thread_messages',
     (code, patientReply, provider) => ({
@@ -323,8 +373,22 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     }),
     { 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 || []);
@@ -401,6 +465,11 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   });
 
   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,

package/package.json

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