@peopl-health/nexus 2.4.9 → 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/controllers/conversationController.js

@@ -1,10 +1,11 @@
 const mongoose = require('mongoose');
-const { fetchConversationData, processConversations } = require('../services/conversationService');
-const { sendMessage } = require('../core/NexusMessaging');
-const { Thread } = require('../models/threadModel');
 const llmConfig = require('../config/llmConfig');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
+const { Thread } = require('../models/threadModel');
+const { withThreadRecovery } = require('../helpers/threadRecoveryHelper');
 const { getRecordByFilter } = require('../services/airtableService');
+const { fetchConversationData, processConversations } = require('../services/conversationService');
+const { sendMessage } = require('../core/NexusMessaging');
 const { logger } = require('../utils/logger');
 
 const Message = mongoose.models.Message;
@@ -649,7 +650,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       });
     }
     
-    const thread = await Thread.findOne({ 
+    let thread = await Thread.findOne({ 
       code: phoneNumber, 
       active: true 
     }).sort({ createdAt: -1 });
@@ -662,7 +663,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       });
     }
     
-    const conversationId = thread.conversation_id;
+    let conversationId = thread.conversation_id;
     logger.info('Thread found - Conversation ID:', conversationId);
     
     const provider = llmConfig.getOpenAIProvider({ instantiate: true, variant });
@@ -683,8 +684,23 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       logger.info('Including runId:', runId);
     }
     
+    let messages;
+    let threadRecreated = false;
+    
     logger.info('Calling listMessages with params:', queryParams);
-    const messages = await provider.listMessages(queryParams);
+    messages = await withThreadRecovery(
+      async (currentThread = thread) => {
+        if (currentThread !== thread) {
+          thread = currentThread;
+          conversationId = currentThread.getConversationId();
+          queryParams.threadId = conversationId;
+          threadRecreated = true;
+        }
+        return await provider.listMessages(queryParams);
+      },
+      thread,
+      variant
+    );
     
     logger.info(`Retrieved ${messages?.data?.length || 0} messages from OpenAI`);
     
@@ -696,6 +712,7 @@ const getOpenAIThreadMessagesController = async (req, res) => {
       assistantId: thread.assistant_id,
       messages: messages.data || messages,
       hasMore: messages.has_more || false,
+      threadRecreated,
       pagination: {
         limit: parseInt(limit),
         order

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

@@ -3,6 +3,7 @@ const llmConfig = require('../config/llmConfig.js');
 const { Thread } = require('../models/threadModel.js');
 const { createProvider } = require('../providers/createProvider.js');
 const { withTracing } = require('../utils/tracingDecorator');
+const { withThreadRecovery } = require('./threadRecoveryHelper');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
 const { logger } = require('../utils/logger');
@@ -58,41 +59,52 @@ 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;
-
-  let run = await provider.runConversation({
-    threadId: thread.getConversationId(),
-    assistantId: thread.getAssistantId(),
-    tools: tools.length > 0 ? tools : undefined,
-    ...runConfigWithAssistant,
-  });
-
-  const filter = thread.code ? { code: thread.code, active: true } : null;
-  if (filter) {
-    await Thread.updateOne(filter, { $set: { run_id: run.id } });
-  }
-
-  const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
-  let completed = false;
-
-  try {
-    logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: thread.getConversationId(), assistantId: thread.getAssistantId() });
-    ({run, completed} = await provider.checkRunStatus(assistant, thread.getConversationId(), run.id, 0, maxRetries));
-  } finally {
-    if (filter) {
-      await Thread.updateOne(filter, { $set: { run_id: null } });
-    }
-  }
+  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(),
+        tools: tools.length > 0 ? tools : undefined,
+        ...runConfigWithAssistant,
+      });
+
+      const filter = currentThread.code ? { code: currentThread.code, active: true } : null;
+      if (filter) {
+        await Thread.updateOne(filter, { $set: { run_id: run.id } });
+      }
+
+      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() });
+        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 } });
+        }
+      }
 
-  if (!completed) {
-    return { run: run, completed: false, output: '' };
-  }
+      if (!completed) {
+        return { run: run, completed: false, output: '', tools_executed };
+      }
 
-  const output = await provider.getRunText({ threadId: thread.getConversationId(), runId: run.id, fallback: '' });
+      const output = await provider.getRunText({ threadId: currentThread.getConversationId(), runId: run.id, fallback: '' });
 
-  return { completed: true, output };
+      return { completed: true, output, tools_executed };
+    },
+    thread,
+    variant
+  );
 };
 
 const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumber) => {
@@ -113,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) => ({
@@ -143,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/filesHelper.js

@@ -1,6 +1,7 @@
 const { PDFDocument } = require('pdf-lib');
 const { execFile } = require('child_process');
 const fs = require('fs').promises;
+const fsSync = require('fs');
 const path = require('path');
 const sharp = require('sharp');
 
@@ -9,11 +10,11 @@ const { Message } = require('../models/messageModel.js');
 const { sanitizeFilename } = require('../utils/sanitizer.js');
 const { logger } = require('../utils/logger');
 
-async function convertPdfToImages(pdfName) {
+async function convertPdfToImages(pdfName, existingPdfPath = null) {
   const outputDir = path.join(__dirname, 'assets', 'tmp');
   
   const sanitizedName = sanitizeFilename(pdfName);
-  const pdfPath = path.join(outputDir, `${sanitizedName}.pdf`);
+  const pdfPath = existingPdfPath || path.join(outputDir, `${sanitizedName}.pdf`);
   const outputPattern = path.join(outputDir, sanitizedName);
 
   await fs.mkdir(outputDir, { recursive: true });
@@ -22,22 +23,52 @@ async function convertPdfToImages(pdfName) {
     const args = ['-jpeg', pdfPath, outputPattern];
     logger.info('[convertPdfToImages] Running: pdftoppm', args.join(' '));
     
-    execFile('pdftoppm', args, (error, stdout, stderr) => {
+    const timeout = 30000;
+    let timedOut = false;
+    
+    const child = execFile('pdftoppm', args, { timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (timedOut) {
+        return;
+      }
+      
       if (error) {
+        logger.error('[convertPdfToImages] Error details:', { 
+          error: error.message, 
+          stderr, 
+          pdfPath,
+          pdfExists: fsSync.existsSync(pdfPath),
+          killed: error.killed,
+          signal: error.signal
+        });
         return reject(new Error(`Error splitting PDF: ${stderr || error.message}`));
       }
 
-      fs.readdir(outputDir, (err, files) => {
-        if (err) {
-          return reject(new Error(`Error reading output directory: ${err.message}`));
-        }
+      logger.info('[convertPdfToImages] pdftoppm completed successfully');
+
+      fs.readdir(outputDir)
+        .then(files => {
+          const jpgFiles = files
+            .filter(file => file.startsWith(sanitizedName) && file.endsWith('.jpg'))
+            .map(file => path.join(outputDir, file));
+
+          logger.info(`[convertPdfToImages] Found ${jpgFiles.length} image files`);
+          resolve(jpgFiles);
+        })
+        .catch(err => {
+          logger.error('[convertPdfToImages] Error reading output directory:', { error: err.message });
+          reject(new Error(`Error reading output directory: ${err.message}`));
+        });
+    });
 
-        const jpgFiles = files
-          .filter(file => file.startsWith(sanitizedName) && file.endsWith('.jpg'))
-          .map(file => path.join(outputDir, file));
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+      logger.error('[convertPdfToImages] Process timed out after 30 seconds', { pdfPath });
+      reject(new Error('PDF conversion timed out after 30 seconds'));
+    }, timeout);
 
-        resolve(jpgFiles);
-      });
+    child.on('exit', () => {
+      clearTimeout(timeoutId);
     });
   });
 }
@@ -130,44 +161,69 @@ const cleanupFiles = async (files) => {
 };
 
 async function downloadMediaAndCreateFile(code, reply) {
-  const resultMedia = await Message.findOne({
-    message_id: reply.message_id,
-    timestamp: reply.timestamp,
-    media: { $ne: null }
-  });
+  try {
+    const resultMedia = await Message.findOne({
+      message_id: reply.message_id,
+      timestamp: reply.timestamp,
+      media: { $ne: null }
+    });
 
-  if (!resultMedia) return [];
+    if (!resultMedia) return [];
 
-  if (!resultMedia.media || !resultMedia.media.key) {
-    logger.info('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
-    return [];
-  }
+    if (!resultMedia.media || !resultMedia.media.key) {
+      logger.info('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
+      return [];
+    }
 
-  const { bucketName, key } = resultMedia.media;
-  if (!bucketName || !key) return [];
-  
-  const [subType, fileName] = key.split('/');
-  
-  const sanitizedCode = sanitizeFilename(code);
-  const sanitizedSubType = sanitizeFilename(subType);
-  const sanitizedFileName = sanitizeFilename(fileName);
-  
-  const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
-  const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
-  
-  await fs.mkdir(path.dirname(downloadPath), { recursive: true });
-  await downloadFileFromS3(bucketName, key, downloadPath);
+    const { bucketName, key } = resultMedia.media;
+    if (!bucketName || !key) return [];
+    
+    const [subType, fileName] = key.split('/');
+    
+    const sanitizedCode = sanitizeFilename(code, 20);
+    const sanitizedSubType = sanitizeFilename(subType, 10);
+    const sanitizedFileName = sanitizeFilename(fileName, 50);
+    
+    const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
+    const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
+    
+    logger.info('[downloadMediaAndCreateFile] Downloading file', { sourceFile, downloadPath, bucketName, key });
+    
+    await fs.mkdir(path.dirname(downloadPath), { recursive: true });
+    await downloadFileFromS3(bucketName, key, downloadPath);
 
-  const { name: baseName } = path.parse(sourceFile);
-  const fileNames = (subType === 'document' ||  subType === 'application')
-    ? await convertPdfToImages(baseName)
-    : [downloadPath];
+    const { name: baseName } = path.parse(sourceFile);
+    let fileNames = [];
+    
+    if (subType === 'document' || subType === 'application') {
+      try {
+        fileNames = await convertPdfToImages(baseName, downloadPath);
+        logger.info('[downloadMediaAndCreateFile] PDF converted successfully', { imageCount: fileNames.length });
+      } catch (conversionError) {
+        logger.error('[downloadMediaAndCreateFile] PDF conversion failed:', { 
+          error: conversionError.message,
+          sourceFile 
+        });
+        fileNames = [];
+      } finally {
+        try {
+          await fs.unlink(downloadPath);
+        } catch (unlinkError) {
+          logger.warn('[downloadMediaAndCreateFile] Failed to delete PDF:', { error: unlinkError.message });
+        }
+      }
+    } else {
+      fileNames = [downloadPath];
+    }
 
-  if (subType === 'document' ||  subType === 'application') {
-    await fs.unlink(downloadPath);
+    return fileNames;
+  } catch (error) {
+    logger.error('[downloadMediaAndCreateFile] Error processing media:', { 
+      error: error.message,
+      message_id: reply.message_id 
+    });
+    return [];
   }
-
-  return fileNames;
 }
 
 module.exports = {

package/lib/helpers/llmsHelper.js

@@ -1,7 +1,7 @@
 const llmConfig = require('../config/llmConfig.js');
 const { logger } = require('../utils/logger');
 const fs = require('fs');
-const mime = require('mime-types');
+const path = require('path');
 
 
 async function analyzeImage(imagePath, isSticker = false, contentType = null) {
@@ -30,14 +30,30 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
       };
     }
     
+    // Determine mime type from file extension
     let mimeType = contentType;
     if (!mimeType) {
-      if (imagePath.toLowerCase().endsWith('.webp')) {
-        mimeType = 'image/webp';
-      } else {
-        mimeType = mime.lookup(imagePath) || 'image/jpeg';
-      }
+      const ext = path.extname(imagePath).toLowerCase();
+      const mimeMap = {
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp'
+      };
+      mimeType = mimeMap[ext] || 'image/jpeg'; // Default to jpeg for pdftoppm output
+    }
+    
+    // Validate that mime type is supported by Claude
+    const supportedMimeTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
+    if (!supportedMimeTypes.includes(mimeType)) {
+      logger.warn('[analyzeImage] Unsupported mime type, defaulting to image/jpeg:', { 
+        originalMimeType: mimeType, 
+        imagePath 
+      });
+      mimeType = 'image/jpeg';
     }
+    
     if (mimeType === 'image/vnd.wap.wbmp') {
       logger.info('Skipping image with MIME type:', mimeType);
       return {
@@ -49,6 +65,7 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
       };
     }
     // Read the image file and convert to base64
+    logger.info('[analyzeImage] Reading image file:', { imagePath: imagePath.split('/').pop() });
     const imageBuffer = await fs.promises.readFile(imagePath);
     const base64Image = imageBuffer.toString('base64');
 
@@ -77,6 +94,7 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
         },
       ],
     });
+    logger.info('[analyzeImage] Description received');
     const description = messageDescription.content[0].text;
 
     // For stickers, skip medical analysis and table extraction

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/helpers/threadRecoveryHelper.js

@@ -0,0 +1,58 @@
+const { Thread } = require('../models/threadModel');
+const { createProvider } = require('../providers/createProvider');
+const { logger } = require('../utils/logger');
+
+const isThreadNotFoundError = (error) => {
+  return error?.status === 404 || 
+         error?.code === 'thread_not_found' ||
+         error?.code === 'invalid_thread_id' ||
+         (error?.message && (
+           error.message.includes('No thread found') ||
+           error.message.includes('thread does not exist') ||
+           error.message.includes('Invalid thread')
+         ));
+};
+
+const recreateThread = async (thread, variant = 'assistants') => {
+  const provider = createProvider({ variant });
+  const newConversation = await provider.createConversation({ 
+    metadata: { phoneNumber: thread.code, recreated: true } 
+  });
+  
+  await Thread.updateOne(
+    { code: thread.code, active: true },
+    { $set: { conversation_id: newConversation.id } }
+  );
+  
+  const updatedThread = await Thread.findOne({ code: thread.code, active: true });
+  logger.info('[threadRecovery] Thread recreated', { 
+    oldId: thread.conversation_id, 
+    newId: newConversation.id,
+    code: thread.code 
+  });
+  
+  return updatedThread;
+};
+
+const withThreadRecovery = async (operation, thread, variant = 'assistants') => {
+  try {
+    return await operation();
+  } catch (error) {
+    if (isThreadNotFoundError(error) && thread) {
+      logger.warn('[threadRecovery] Thread not found, recreating', { 
+        conversationId: thread.getConversationId?.() || thread.conversation_id,
+        code: thread.code 
+      });
+      
+      const recoveredThread = await recreateThread(thread, variant);
+      return await operation(recoveredThread);
+    }
+    throw error;
+  }
+};
+
+module.exports = {
+  isThreadNotFoundError,
+  recreateThread,
+  withThreadRecovery
+};

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

@@ -14,6 +14,7 @@ const { getThread, getThreadInfo } = require('../helpers/threadHelper.js');
 const { withTracing } = require('../utils/tracingDecorator.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
 const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
+const { withThreadRecovery } = require('../helpers/threadRecoveryHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { logger } = require('../utils/logger');
 
@@ -137,13 +138,19 @@ const getAssistantById = (assistant_id, thread) => {
 const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   const findThread = await Thread.findOne({ code: code });
   logger.info('[createAssistant] findThread', findThread);
-  if (findThread && findThread.getConversationId()) {
+  if (findThread && findThread.getConversationId() && !force) {
     logger.info('[createAssistant] Thread already exists');
     const updateFields = { active: true, stopped: false };
     Thread.setAssistantId(updateFields, assistant_id);    
     await Thread.updateOne({ code: code }, { $set: updateFields });
     return findThread;
   }
+
+  if (force && findThread?.getConversationId()) {
+    const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+    await provider.deleteConversation(findThread.getConversationId());
+    logger.info('[createAssistant] Deleted old conversation, will create new one');
+  }
   
   const curRow = await getCurRow(Historial_Clinico_ID, code);
   logger.info('[createAssistant] curRow', curRow[0]);
@@ -153,7 +160,6 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const assistant = getAssistantById(assistant_id, null);
   const initialThread = await assistant.create(code, curRow[0]);
 
-  // Add new messages to memory
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   for (const message of messages) {
     await provider.addMessage({
@@ -177,29 +183,32 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
   logger.info('[createAssistant] Updated thread:', updatedThread);
 
-  // Delete previous thread
-  if (force) {
-    await provider.deleteConversation(findThread.getConversationId());
-  }
-
   return thread;
 };
 
 const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) => {
   try {
-    const thread = await Thread.findOne({ code: code });
+    let thread = await Thread.findOne({ code: code });
     logger.info(thread);
     if (thread === null) return null;
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-    for (const message of inMessages) {
-      logger.info(message);
-      await provider.addMessage({
-        threadId: thread.getConversationId(),
-        role: role,
-        content: message
-      });
-    }
+    
+    await withThreadRecovery(
+      async (recoveredThread = thread) => {
+        thread = recoveredThread;
+        for (const message of inMessages) {
+          logger.info(message);
+          await provider.addMessage({
+            threadId: thread.getConversationId(),
+            role: role,
+            content: message
+          });
+        }
+      },
+      thread,
+      process.env.VARIANT || 'assistants'
+    );
 
     if (!reply) return null;
 
@@ -322,9 +331,15 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
   
   if (allMessagesToAdd.length > 0) {
-    const threadId = finalThread.getConversationId();
     logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
-    await provider.addMessage({ threadId, messages: allMessagesToAdd });
+    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)));
@@ -374,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) {
@@ -397,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.9",
+  "version": "2.4.11-logs",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",