@peopl-health/nexus 2.4.10 → 2.4.11

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/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",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",