@peopl-health/nexus 2.4.10 → 2.4.11-logs

package/lib/assistants/BaseAssistant.js

@@ -197,7 +197,10 @@ class BaseAssistant {
     }
 
     try {
-      const lastMessages = await Message.find({ numero: whatsappId })
+      const lastMessages = await Message.find({ 
+        numero: whatsappId,
+        interactive_type: { $ne: 'flow' }
+      })
         .sort({ createdAt: -1 })
         .limit(DEFAULT_MAX_HISTORICAL_MESSAGES);
 

package/lib/core/NexusMessaging.js

@@ -442,14 +442,17 @@ class NexusMessaging {
         return;
       }
 
-      const response = await replyAssistant(from, body);
+      const result = await replyAssistant(from, body);
+      const response = typeof result === 'string' ? result : result?.output;
+      const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
 
       if (response) {
         await this.sendMessage({
           code: from,
           body: response,
           processed: true,
-          origin: 'assistant'
+          origin: 'assistant',
+          tools_executed
         });
       }
     } catch (error) {
@@ -506,14 +509,17 @@ class NexusMessaging {
         ? body
         : `Media received (${mediaDescriptor || 'attachment'})`;
 
-      const response = await replyAssistant(from, fallbackMessage);
+      const result = await replyAssistant(from, fallbackMessage);
+      const response = typeof result === 'string' ? result : result?.output;
+      const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
 
       if (response) {
         await this.sendMessage({
           code: from,
           body: response,
           processed: true,
-          origin: 'assistant'
+          origin: 'assistant',
+          tools_executed
         });
       }
     } catch (error) {
@@ -647,13 +653,17 @@ class NexusMessaging {
       logger.info(`Processing batched messages from ${chatId} (including media if any)`);
       
       // Get assistant response
-      const botResponse = await replyAssistant(chatId);
+      const result = await replyAssistant(chatId);
+      const botResponse = typeof result === 'string' ? result : result?.output;
+      const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
+      
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
           body: botResponse,
           processed: true,
-          origin: 'assistant'
+          origin: 'assistant',
+          tools_executed
         });
       }
       

package/lib/helpers/assistantHelper.js

@@ -59,12 +59,13 @@ const runAssistantAndWait = async ({
   const variant = provider.getVariant ? provider.getVariant() : (process.env.VARIANT || 'assistants');
   const tools = assistant.getToolSchemas ? assistant.getToolSchemas() : (configTools || []);
 
-  const runConfigWithAssistant = variant === 'responses'
-    ? { ...conversationConfig, assistant }
-    : conversationConfig;
-
   return await withThreadRecovery(
     async (currentThread = thread) => {
+      const toolMetadata = { numero: currentThread.code, assistant_id: currentThread.getAssistantId() };
+      const runConfigWithAssistant = variant === 'responses'
+        ? { ...conversationConfig, assistant, toolMetadata }
+        : conversationConfig;
+
       let run = await provider.runConversation({
         threadId: currentThread.getConversationId(),
         assistantId: currentThread.getAssistantId(),
@@ -79,10 +80,14 @@ const runAssistantAndWait = async ({
 
       const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
       let completed = false;
+      let tools_executed = run.tools_executed || [];
 
       try {
         logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: currentThread.getConversationId(), assistantId: currentThread.getAssistantId() });
-        ({run, completed} = await provider.checkRunStatus(assistant, currentThread.getConversationId(), run.id, 0, maxRetries));
+        const result = await provider.checkRunStatus(assistant, currentThread.getConversationId(), run.id, 0, maxRetries, false, toolMetadata);
+        run = result.run;
+        completed = result.completed;
+        tools_executed = [...tools_executed, ...(result.tools_executed || [])];
       } finally {
         if (filter) {
           await Thread.updateOne(filter, { $set: { run_id: null } });
@@ -90,12 +95,12 @@ const runAssistantAndWait = async ({
       }
 
       if (!completed) {
-        return { run: run, completed: false, output: '' };
+        return { run: run, completed: false, output: '', tools_executed };
       }
 
       const output = await provider.getRunText({ threadId: currentThread.getConversationId(), runId: run.id, fallback: '' });
 
-      return { completed: true, output };
+      return { completed: true, output, tools_executed };
     },
     thread,
     variant
@@ -120,13 +125,13 @@ const runAssistantWithRetries = async (thread, assistant, runConfig, patientRepl
   }
 
   const startTime = Date.now();
-  let run, output, completed;
+  let run, output, completed, tools_executed;
   let retries = 0;
   const maxRetries = DEFAULT_MAX_RETRIES;
   
   do {
     retries++;
-    ({ run, output, completed } = await withTracing(
+    ({ run, output, completed, tools_executed } = await withTracing(
       executeAssistantAttempt,
       'assistant_attempt',
       (thread, assistant, runConfig, attemptNumber) => ({
@@ -150,10 +155,10 @@ const runAssistantWithRetries = async (thread, assistant, runConfig, patientRepl
   const predictionTimeMs = Date.now() - startTime;
 
   if (run?.last_error) logger.warn('[runAssistantWithRetries] Run error', { error: run.last_error });
-  logger.info('[runAssistantWithRetries] Run completed', { completed, outputLength: output?.length || 0 });
+  logger.info('[runAssistantWithRetries] Run completed', { completed, outputLength: output?.length || 0, toolsExecuted: tools_executed?.length || 0 });
   logger.info('[runAssistantWithRetries] TIMING', { predictionTimeMs, retries });
   
-  return { run, output, completed, retries, predictionTimeMs };
+  return { run, output, completed, retries, predictionTimeMs, tools_executed };
 };
 
 module.exports = {

package/lib/helpers/messageHelper.js

@@ -5,6 +5,11 @@ const { logger } = require('../utils/logger');
 const addMessageToThread = async (reply, messagesChat, provider, thread) => {
   const threadId = thread.getConversationId();
   
+  if (reply.interactive_type === 'flow') {
+    logger.info(`[addMessageToThread] Skipping flow message (UI only) - ID: ${reply.message_id}`);
+    return;
+  }
+  
   if (reply.origin === 'whatsapp_platform') {
     await provider.addMessage({
       threadId,

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,7 +57,7 @@ const processTextMessage = (reply) => {
   return messagesChat;
 };
 
-const processImageFile = async (fileName, reply) => {
+const processImageFileCore = async (fileName, reply) => {
   let imageAnalysis = null;
   let url = null;
   const messagesChat = [];
@@ -66,25 +67,21 @@ const processImageFile = async (fileName, reply) => {
                     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 });
+    imageAnalysis = await withTracing(
+      analyzeImage,
+      'analyze_image',
+      () => ({ 'image.is_sticker': isSticker, 'image.message_id': reply.message_id })
+    )(fileName, isSticker, reply.media?.contentType);
     
     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);            
+      url = await withTracing(
+        generatePresignedUrl,
+        'generate_presigned_url',
+        () => ({ 'url.bucket': reply.media.bucketName })
+      )(reply.media.bucketName, reply.media.key);
     }
     
     // Add appropriate text based on analysis
@@ -104,6 +101,17 @@ 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'
+    });
+    
+    logger.debug('processImageFile_analysis', { imageAnalysis });
+    
   } catch (error) {
     logger.error('processImageFile', error, {
       message_id: reply.message_id,
@@ -119,15 +127,28 @@ const processImageFile = async (fileName, reply) => {
   return { messagesChat, url };
 };
 
-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 = [];
   
   try {
-    const audioTranscript = await provider.transcribeAudio({
-      file: fs.createReadStream(fileName),
-      responseFormat: 'text',
-      language: 'es'
-    });
+    const audioTranscript = 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' })
+    )();
     
     const transcriptText = audioTranscript?.text || audioTranscript;
     messagesChat.push({
@@ -156,7 +177,15 @@ const processAudioFile = async (fileName, provider) => {
   return messagesChat;
 };
 
-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 = [];
@@ -165,22 +194,16 @@ const processMediaFiles = async (code, reply, provider) => {
     return { messagesChat, url, tempFiles };
   }
 
-  logger.info('processMediaFiles', {
-    message_id: reply.message_id,
-    processing_media: true
-  });
-  
-  const fileNames = await downloadMediaAndCreateFile(code, reply);
+  const fileNames = await withTracing(
+    downloadMediaAndCreateFile,
+    'download_media',
+    () => ({ 'media.message_id': reply.message_id, 'media.type': reply.media?.mediaType })
+  )(code, reply);
   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', {
@@ -209,21 +232,35 @@ const processMediaFiles = async (code, reply, provider) => {
     }
   }
 
+  logger.info('processMediaFiles_complete', {
+    message_id: reply.message_id,
+    file_count: fileNames.length
+  });
+
   return { messagesChat, url, tempFiles };
 };
 
-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 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 textMessages = processTextMessage(reply);
+        const mediaResult = await processMediaFiles(code, reply, provider);
         
         const { messagesChat: mediaMessages, url, tempFiles: mediaFiles } = mediaResult;
         tempFiles = mediaFiles;
@@ -235,22 +272,39 @@ 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: [] };
       }
     })
   );
   
+  logger.info('processThreadMessage_complete', {
+    message_count: replyArray.length
+  });
+  
   return results;
 };
 
+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

@@ -32,6 +32,15 @@ const messageSchema = new mongoose.Schema({
     type: String, 
     enum: ['whatsapp_platform', 'assistant', 'patient'], 
     default: 'whatsapp_platform' },
+  tools_executed: [{
+    tool_name: { type: String, required: true },
+    tool_arguments: { type: Object, default: null },
+    tool_output: { type: Object, default: null },
+    execution_time_ms: { type: Number, default: null },
+    success: { type: Boolean, default: true },
+    call_id: { type: String, default: null },
+    executed_at: { type: Date, default: Date.now }
+  }],
   media: {
     contentType: { type: String, default: null },
     bucketName: { type: String, default: null },
@@ -108,6 +117,7 @@ async function insertMessage(values) {
       content_sid: values.content_sid || null,
       clinical_context: clinical_context,
       origin: values.origin,
+      tools_executed: values.tools_executed || [],
       raw: values.raw || null
     };
 

package/lib/providers/OpenAIResponsesProvider.js

@@ -280,19 +280,23 @@ class OpenAIResponsesProvider {
     tools = [],
     model,
     assistant,
+    toolMetadata,
   } = {}) {
     try {
       const id = this._ensurethreadId(threadId);
       const messages = this._responseInput(additionalMessages) || [];
 
-      // Check for pending function calls in the conversation before creating a new response
+      const execMetadata = toolMetadata || { thread_id: id, assistant_id: assistantId };
+      let toolsExecuted = [];
+      
       if (assistant && toolOutputs.length === 0) {
         try {
           const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
           const items = conversationMessages?.data || [];
-          const pendingOutputs = await handlePendingFunctionCallsUtil(assistant, items);
-          if (pendingOutputs.length > 0) {
-            toolOutputs = pendingOutputs;
+          const result = await handlePendingFunctionCallsUtil(assistant, items, execMetadata);
+          if (result.outputs && result.outputs.length > 0) {
+            toolOutputs = result.outputs;
+            toolsExecuted = result.toolsExecuted || [];
           }
         } catch (error) {
           logger.warn('[OpenAIResponsesProvider] Error checking for pending function calls:', error?.message);
@@ -329,6 +333,7 @@ class OpenAIResponsesProvider {
         thread_id: id,
         assistant_id: assistantId,
         object: response.object || 'response',
+        tools_executed: toolsExecuted,
       };
     } catch (error) {
       logger.error('[OpenAIResponsesProvider] Error running conversation:', error);
@@ -423,27 +428,31 @@ class OpenAIResponsesProvider {
     return await handleRequiresActionUtil(assistant, run);
   }
 
-  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
+  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false, toolMetadata = {}, accumulatedTools = []) {
     try {
       let run = await this.getRun({ threadId: thread_id, runId: run_id });
       logger.info(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
 
       if (run.status === 'completed') {
-        return {run, completed: true};
+        return {run, completed: true, tools_executed: accumulatedTools};
       }
 
       if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
-        return {run, completed: false};
+        return {run, completed: false, tools_executed: accumulatedTools};
       }
 
       const needsFunctionCall = run.output?.some(item => item.type === 'function_call');
       if (needsFunctionCall && !actionHandled) {
         if (retryCount >= maxRetries) {
           logger.warn('[OpenAIResponsesProvider] Max retries reached while handling function calls');
-          return {run, completed: false};
+          return {run, completed: false, tools_executed: accumulatedTools};
         }
 
-        const outputs = await handleRequiresActionUtil(assistant, run);
+        const execMetadata = { ...toolMetadata, thread_id, run_id };
+        const result = await handleRequiresActionUtil(assistant, run, execMetadata);
+        const outputs = result.outputs || [];
+        const toolsExecuted = result.toolsExecuted || [];
+        
         logger.info('[OpenAIResponsesProvider] Function call outputs:', outputs);
         
         if (outputs.length > 0) {
@@ -456,30 +465,30 @@ class OpenAIResponsesProvider {
             
             await new Promise(resolve => setTimeout(resolve, 1000));
             
-            return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true);
+            return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true, toolMetadata, [...accumulatedTools, ...toolsExecuted]);
           } catch (submitError) {
             logger.error('[OpenAIResponsesProvider] Error submitting tool outputs:', submitError);
             if (retryCount < maxRetries) {
               await new Promise(resolve => setTimeout(resolve, 2000));
-              return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, false);
+              return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, false, toolMetadata, accumulatedTools);
             }
-            return {run, completed: false};
+            return {run, completed: false, tools_executed: accumulatedTools};
           }
         } else {
           logger.warn('[OpenAIResponsesProvider] Function calls detected but no outputs generated');
-          return {run, completed: false};
+          return {run, completed: false, tools_executed: accumulatedTools};
         }
       }
 
       if (retryCount < maxRetries) {
         await new Promise(resolve => setTimeout(resolve, 1000));
-        return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
+        return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled, toolMetadata, accumulatedTools);
       }
 
-      return {run, completed: false};
+      return {run, completed: false, tools_executed: accumulatedTools};
     } catch (error) {
       logger.error('[OpenAIResponsesProvider] Error checking run status:', error);
-      return {run: null, completed: false};
+      return {run: null, completed: false, tools_executed: accumulatedTools};
     }
   }
 

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -1,27 +1,52 @@
 const { logger } = require('../utils/logger');
 
-/**
- * Execute a function call and return the output format
- * @param {Object} assistant - The assistant instance with executeTool method
- * @param {Object} call - The function call object with name, arguments, and call_id
- * @returns {Promise<Object>} Function call output in Responses API format
- */
-async function executeFunctionCall(assistant, call) {
+async function executeFunctionCall(assistant, call, metadata = {}) {
+  const startTime = Date.now();
   try {
     const name = call.name;
     const args = call.arguments ? JSON.parse(call.arguments) : {};
     const result = await assistant.executeTool(name, args);
-    return {
-      type: 'function_call_output',
+    const executionTime = Date.now() - startTime;
+    
+    const toolData = {
+      tool_name: name,
+      tool_arguments: args,
+      tool_output: result,
+      execution_time_ms: executionTime,
+      success: true,
       call_id: call.call_id,
-      output: typeof result === 'string' ? result : JSON.stringify(result)
+      executed_at: new Date()
+    };
+    
+    return {
+      functionOutput: {
+        type: 'function_call_output',
+        call_id: call.call_id,
+        output: typeof result === 'string' ? result : JSON.stringify(result)
+      },
+      toolData
     };
   } catch (error) {
+    const executionTime = Date.now() - startTime;
+    
+    const toolData = {
+      tool_name: call.name,
+      tool_arguments: call.arguments ? JSON.parse(call.arguments) : {},
+      tool_output: { error: error?.message || 'Tool execution failed' },
+      execution_time_ms: executionTime,
+      success: false,
+      call_id: call.call_id,
+      executed_at: new Date()
+    };
+    
     logger.error('[OpenAIResponsesProvider] Tool execution failed', error);
     return {
-      type: 'function_call_output',
-      call_id: call.call_id,
-      output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+      functionOutput: {
+        type: 'function_call_output',
+        call_id: call.call_id,
+        output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+      },
+      toolData
     };
   }
 }
@@ -32,7 +57,7 @@ async function executeFunctionCall(assistant, call) {
  * @param {Array} conversationItems - Array of conversation items
  * @returns {Promise<Array>} Array of function call outputs
  */
-async function handlePendingFunctionCalls(assistant, conversationItems) {
+async function handlePendingFunctionCalls(assistant, conversationItems, metadata = {}) {
   const pendingFunctionCalls = conversationItems.filter(item => item.type === 'function_call');
   const functionOutputs = conversationItems.filter(item => item.type === 'function_call_output');
   
@@ -41,15 +66,20 @@ async function handlePendingFunctionCalls(assistant, conversationItems) {
   );
   
   if (orphanedCalls.length === 0) {
-    return [];
+    return { outputs: [], toolsExecuted: [] };
   }
 
   logger.info(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
   const outputs = [];
+  const toolsExecuted = [];
+  
   for (const call of orphanedCalls) {
-    outputs.push(await executeFunctionCall(assistant, call));
+    const result = await executeFunctionCall(assistant, call, metadata);
+    outputs.push(result.functionOutput);
+    toolsExecuted.push(result.toolData);
   }
-  return outputs;
+  
+  return { outputs, toolsExecuted };
 }
 
 /**
@@ -58,18 +88,22 @@ async function handlePendingFunctionCalls(assistant, conversationItems) {
  * @param {Object} run - The run object with output array
  * @returns {Promise<Array>} Array of function call outputs
  */
-async function handleRequiresAction(assistant, run) {
+async function handleRequiresAction(assistant, run, metadata = {}) {
   const functionCalls = run.output?.filter(item => item.type === 'function_call') || [];
   if (functionCalls.length === 0) {
-    return [];
+    return { outputs: [], toolsExecuted: [] };
   }
 
   const outputs = [];
+  const toolsExecuted = [];
+  
   for (const call of functionCalls) {
-    outputs.push(await executeFunctionCall(assistant, call));
+    const result = await executeFunctionCall(assistant, call, metadata);
+    outputs.push(result.functionOutput);
+    toolsExecuted.push(result.toolData);
   }
 
-  return outputs;
+  return { outputs, toolsExecuted };
 }
 
 /**

package/lib/services/assistantService.js

@@ -389,14 +389,15 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   timings.run_assistant_ms = runAssistantMs;
   timings.total_ms = Date.now() - startTotal;
   
-  const { run, output, completed, retries, predictionTimeMs } = runResult;
+  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
+    totalMs: timings.total_ms,
+    toolsExecuted: tools_executed?.length || 0
   });
 
   if (output && predictionTimeMs) {
@@ -412,7 +413,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
   }
 
-  return output;
+  return { output, tools_executed };
 };
 
 const replyAssistant = withTracing(

package/lib/storage/MongoStorage.js

@@ -186,7 +186,8 @@ class MongoStorage {
       content_sid: messageData.contentSid || null,
       template_variables: messageData.variables ? JSON.stringify(messageData.variables) : null,
       raw: messageData.raw || null,
-      origin
+      origin,
+      tools_executed: messageData.tools_executed || []
     };
   }
 

package/lib/utils/messageParser.js

@@ -198,8 +198,11 @@ class MessageParser {
       return interactive.title || interactive.description || '[List item selected]';
       
     case 'flow':
-      // Flows contain complex JSON data that doesn't need assistant processing
-      return '';
+      if (interactive.data) {
+        const flowData = typeof interactive.data === 'string' ? interactive.data : JSON.stringify(interactive.data, null, 2);
+        return `Flow Response:\n${flowData}`;
+      }
+      return '[Flow response]';
       
     default:
       return '[Interactive message]';

package/package.json

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