@peopl-health/nexus 2.2.10 → 2.3.1

package/lib/adapters/TwilioProvider.js

@@ -108,12 +108,6 @@ class TwilioProvider extends MessageProvider {
       const result = await this.twilioClient.messages.create(messageParams);
       if (this.messageStorage && typeof this.messageStorage.saveMessage === 'function') {
         try {
-          console.log('[TwilioProvider] Persisting outbound message', {
-            code: formattedCode,
-            from: formattedFrom,
-            hasMedia: Boolean(messageParams.mediaUrl && messageParams.mediaUrl.length),
-            hasTemplate: Boolean(messageParams.contentSid)
-          });
           await this.messageStorage.saveMessage({
             ...messageData,
             code: formattedCode,

package/lib/helpers/assistantHelper.js

@@ -1,18 +1,12 @@
-const { downloadFileFromS3, generatePresignedUrl } = require('../config/awsConfig.js');
 const llmConfig = require('../config/llmConfig.js');
 
-const { Message } = require('../models/messageModel.js');
-
-const { convertPdfToImages } = require('./filesHelper.js');
-const { analyzeImage } = require('../helpers/llmsHelper.js');
+const { Thread } = require('../models/threadModel.js');
+const { createProvider } = require('../providers/createProvider.js');
+const { withTracing } = require('../utils/tracingDecorator');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
 
-const fs = require('fs');
-const path = require('path');
-const moment = require('moment-timezone');
-
-const mode = process.env.NODE_ENV || 'dev';
+const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
 async function checkIfFinished(text) {
   try {
@@ -33,292 +27,121 @@ async function checkIfFinished(text) {
     
     return completion.choices[0].message.content;
   } catch (error) {
-    console.error('Error checking run status:', error);
+    console.error('[checkIfFinished] Error checking run status:', error);
   }
 }
 
-async function getLastMessages(code) {
-  try {
-    let query = { processed: false };
-    if (code.endsWith('@g.us')) {
-      query.group_id = code;
-      query.numero = { $nin: ['5215592261426@s.whatsapp.net', '5215547411345@s.whatsapp.net'] };
-    } else {
-      query.numero = code;
-      query.is_group = false;
-    }
-
-    const lastMessages = await Message.find(query).sort({ createdAt: -1 });
-    console.log('[getLastMessages] lastMessages', lastMessages.map(msg => msg.body).join('\n\n'));
-
-    if (lastMessages.length === 0) return [];
-
-    let patientReply = [];
-    for (const message of lastMessages) {
-      patientReply.push(message);
-      await Message.updateOne(
-        { message_id: message.message_id, timestamp: message.timestamp },
-        { $set: { processed: true } }
-      );
-    }
-
-    console.log('[getLastMessages] Marked', patientReply.length, 'messages as processed');
-    return patientReply.reverse();
-  } catch (error) {
-    console.error('Error getting the last user messages:', error);
-    return [];
+function getCurRow(baseID, code) {
+  if (code.endsWith('@g.us')) {
+    return getRecordByFilter(baseID, 'estado_general', `FIND("${code}", {Group ID})`);
+  } else {
+    return getRecordByFilter(baseID, 'estado_general', `FIND("${code.split('@')[0]}", {whatsapp_id})`);
   }
 }
 
-async function getLastNMessages(code, n) {
-  try {
-    const lastMessages = await Message.find({ numero: code })
-      .sort({ createdAt: -1 })
-      .limit(n);
-
-    // Format each message and concatenate them with skip lines
-    const formattedMessages = lastMessages
-      .reverse()
-      .map(message => formatMessage(message))
-      .filter(formatted => formatted !== null) // Filter out any null results from formatMessage
-      .join('\n\n');
-
-    console.log('[getLastNMessages] Fetched last messages:', formattedMessages);
-
-    return formattedMessages;
-  } catch (error) {
-    console.error('Error retrieving the last user messages:', error);
-    return '';
+const runAssistantAndWait = async ({
+  thread,
+  assistant,
+  runConfig = {}
+}) => {
+  if (!thread || !thread.getConversationId()) {
+    throw new Error('runAssistantAndWait requires a thread with a valid thread_id or conversation_id');
   }
-}
 
-const getPatientRoleAndName = (reply, numbers) => {
-  let role = 'familiar';
-  let name = reply.nombre_whatsapp;
-  for (const [key, value] of Object.entries(numbers)) {
-    console.log(key, value, reply.numero);
-    if (value[reply.numero]) {
-      role = key;
-      name = value[reply.numero];
-      break;
-    }
+  if (!assistant) {
+    throw new Error('runAssistantAndWait requires an assistant instance');
   }
-  if (mode === 'prod') {
-    if (reply.from_me) {
-      role = 'asistente';
-      name = 'Pipo';
-    }
-  }
-  return { role, name };
-};
 
-function formatMessage(reply) {
-  try {
-    if (!reply.timestamp) {
-      return null;
-    }
-    
-    // Normalize timestamp: convert any format to a Date object, then to ISO string
-    let dateObj;
-    
-    if (reply.timestamp instanceof Date) {
-      dateObj = reply.timestamp;
-    } else if (typeof reply.timestamp === 'number') {
-      const ms = reply.timestamp < 1e12 ? reply.timestamp * 1000 : reply.timestamp;
-      dateObj = new Date(ms);
-    } else {
-      dateObj = new Date(reply.timestamp);
-    }
-    
-    if (isNaN(dateObj.getTime())) {
-      console.warn('[formatMessage] Invalid timestamp:', reply.timestamp);
-      return null;
-    }
-    
-    const isoString = dateObj.toISOString();
-    
-    // Convert timestamp to Mexico City timezone with Spanish format
-    // Format: martes, 30 de septiembre de 2025 a las 8:30 AM
-    const mexicoCityTime = moment(isoString)
-      .tz('America/Mexico_City')
-      .locale('es')
-      .format('dddd, D [de] MMMM [de] YYYY [a las] h:mm A');
-    
-    return `[${mexicoCityTime}] ${reply.body}`;
-  } catch (error) {
-    console.error('[formatMessage] Error formatting message:', error?.message || error, 'timestamp:', reply.timestamp);
-    return null;
-  } 
-}
+  const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
+  const { polling, tools: configTools, ...conversationConfig } = runConfig || {};
+  const variant = provider.getVariant ? provider.getVariant() : (process.env.VARIANT || 'assistants');
+  const tools = assistant.getToolSchemas ? assistant.getToolSchemas() : (configTools || []);
 
-async function downloadMediaAndCreateFile(code, reply) {
-  const resultMedia = await Message.findOne({
-    message_id: reply.message_id,
-    timestamp: reply.timestamp,
-    media: { $ne: null }
-  });
+  const runConfigWithAssistant = variant === 'responses'
+    ? { ...conversationConfig, assistant }
+    : conversationConfig;
 
-  if (!resultMedia) return [];
+  let run = await provider.runConversation({
+    threadId: thread.getConversationId(),
+    assistantId: thread.getAssistantId(),
+    tools: tools.length > 0 ? tools : undefined,
+    ...runConfigWithAssistant,
+  });
 
-  if (!resultMedia.media || !resultMedia.media.key) {
-    console.log('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
-    return [];
+  const filter = thread.code ? { code: thread.code, active: true } : null;
+  if (filter) {
+    await Thread.updateOne(filter, { $set: { run_id: run.id } });
   }
 
-  const { bucketName, key } = resultMedia.media;
-  if (!bucketName || !key) return [];
-  const [subType, fileName] = key.split('/');
-  const sourceFile = `${code}-${subType}-${fileName}`;
-  const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
-  console.log(bucketName, key);
-  await downloadFileFromS3(bucketName, key, downloadPath);
-
-  const fileNames = (subType === 'document' ||  subType === 'application')
-    ? await convertPdfToImages(sourceFile.split('.')[0])
-    : [downloadPath];
+  const maxRetries = polling?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  let completed = false;
 
-  if (subType === 'document' ||  subType === 'application') {
-    await fs.promises.unlink(downloadPath);
-  }
-    
-  console.log(fileNames);
-
-  return fileNames;
-}
-
-async function processIndividualMessage(code, reply, provider, thread) {
-  const tempFiles = [];
   try {
-    const formattedMessage = formatMessage(reply);
-    console.log('[processIndividualMessage] formattedMessage:', formattedMessage);
-    const isPatient = reply.origin === 'patient';
-    let messagesChat = [];
-    let url = null;
-
-    if (formattedMessage) {
-      messagesChat.push({ type: 'text', text: formattedMessage });
+    console.log('[runAssistantAndWait] RUN ID', run.id, 'THREAD ID', thread.getConversationId(), 'ASSISTANT ID', 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 } });
     }
+  }
 
-    // Handle media if present
-    if (reply.is_media) {
-      console.log('IS MEDIA', reply.is_media);
-      const fileNames = await downloadMediaAndCreateFile(code, reply);
-      tempFiles.push(...fileNames);
-      for (const fileName of fileNames) {
-        console.log(fileName);
-        // Skip WBMP images and stickers
-        if (fileName.toLowerCase().includes('.wbmp') || fileName.toLowerCase().includes('sticker')) {
-          console.log('Skipping WBMP image or sticker:', fileName);
-          continue;
-        }
-        if (fileName.includes('image') || fileName.includes('document') || fileName.includes('application')) {
-          let imageAnalysis = null;
-          try {
-            imageAnalysis = await analyzeImage(fileName);
-          } catch (error) {
-            console.warn('[assistantHelper] analyzeImage failed:', error?.message || error);
-          }
-          console.log(imageAnalysis);
-          const invalidAnalysis = ['NOT_MEDICAL', 'QUALITY_INSUFFICIENT'];
-          if (imageAnalysis?.medical_relevance) {
-            url = await generatePresignedUrl(reply.media.bucketName, reply.media.key);            
-          }
-          if (imageAnalysis?.has_table && imageAnalysis.table_data) {
-            messagesChat.push({
-              type: 'text',
-              text: imageAnalysis.table_data,
-            });
-          } else if (imageAnalysis?.medical_analysis && !invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
-            messagesChat.push({
-              type: 'text',
-              text: imageAnalysis.medical_analysis,
-            });
-          } else {
-            console.log('Add attachment');
-            /*const file = await provider.uploadFile({
-              file: fs.createReadStream(fileName),
-              purpose: 'vision',
-            });
-            messagesChat.push({
-              type: 'image_file',
-              image_file: { file_id: file.id },
-            });*/
-            messagesChat.push({
-              type: 'text',
-              text: imageAnalysis.description,
-            });
-          }
-        } else if (fileName.includes('audio')) {
-          const audioTranscript = await provider.transcribeAudio({
-            file: fs.createReadStream(fileName),
-            responseFormat: 'text',
-            language: 'es'
-          });
-          const transcriptText = audioTranscript?.text || audioTranscript;
-          messagesChat.push({
-            type: 'text',
-            text: transcriptText,
-          });
-        }
-      }
-    }
+  if (!completed) {
+    return { run: run, completed: false, output: '' };
+  }
 
-    console.log('[processIndividualMessage] messagesChat', messagesChat);
+  const output = await provider.getRunText({ threadId: thread.getConversationId(), runId: run.id, fallback: '' });
 
-    const threadId = thread.getConversationId();
-    if (reply.origin === 'whatsapp_platform') {
-      await provider.addMessage({
-        threadId,
-        role: 'assistant',
-        content: messagesChat
-      });
-    } else if (reply.origin === 'patient') {
-      await provider.addMessage({
-        threadId,
-        role: 'user',
-        content: messagesChat
-      });
-    }
+  return { completed: true, output };
+};
 
-    await Message.updateOne(
-      { message_id: reply.message_id, timestamp: reply.timestamp },
-      { $set: { assistant_id: thread.getAssistantId(), thread_id: threadId } }
-    );
+const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumber) => {
+  const result = await runAssistantAndWait({
+    thread,
+    assistant,
+    runConfig
+  });
+  
+  console.log(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
+  
+  return result;
+};
 
-    return {isPatient, url};
-  } catch (err) {
-    console.log(`Error inside process message ${err}`);
-  } finally {
-    if (tempFiles.length > 0) {
-      await Promise.all(tempFiles.map(async (filePath) => {
-        try {
-          await fs.promises.unlink(filePath);
-        } catch (error) {
-          if (error?.code !== 'ENOENT') {
-            console.warn('[processIndividualMessage] Failed to remove temp file:', filePath, error?.message || error);
-          }
-        }
-      }));
-    }
+const runAssistantWithRetries = async (thread, assistant, runConfig, patientReply = null) => {
+  if (patientReply) {
+    assistant.setReplies(patientReply);
   }
-}
 
-function getCurRow(baseID, code) {
-  if (code.endsWith('@g.us')) {
-    return getRecordByFilter(baseID, 'estado_general', `FIND("${code}", {Group ID})`);
-  } else {
-    console.log(code, `FIND("${code.split('@')[0]}", {whatsapp_id})`);
-    return getRecordByFilter(baseID, 'estado_general', `FIND("${code.split('@')[0]}", {whatsapp_id})`);
-  }
-}
+  let run, output, completed;
+  let retries = 0;
+  const maxRetries = DEFAULT_MAX_RETRIES;
+  
+  do {
+    retries++;
+    ({ run, output, completed } = await withTracing(
+      executeAssistantAttempt,
+      'assistant_attempt',
+      (thread, assistant, runConfig, attemptNumber) => ({
+        'attempt.number': attemptNumber,
+        'attempt.is_retry': attemptNumber > 1,
+        'attempt.max_attempts': maxRetries
+      })
+    )(thread, assistant, runConfig, retries));
+    
+    if (completed && output) break;
+    if (retries < maxRetries) await new Promise(resolve => setTimeout(resolve, 2000));
+  } while (retries < maxRetries && (!completed || !output));
+
+  if (run?.last_error) console.log('[runAssistantWithRetries] RUN LAST ERROR:', run.last_error);
+  console.log('[runAssistantWithRetries] RUN STATUS', completed);
+  console.log('[runAssistantWithRetries] OUTPUT', output);
+  
+  return { run, output, completed, retries };
+};
 
 module.exports = {
   checkIfFinished,
-  getLastMessages,
-  getLastNMessages,
-  getPatientRoleAndName,
   getCurRow,
-  formatMessage,
-  downloadMediaAndCreateFile,
-  processIndividualMessage
+  runAssistantAndWait,
+  runAssistantWithRetries,
+  executeAssistantAttempt
 };

package/lib/helpers/baileysHelper.js

@@ -1,5 +1,6 @@
 const { Message, insertMessage, getMessageValues } = require('../models/messageModel.js');
 const { uploadMediaToS3 } = require('./mediaHelper.js');
+const { isRecentMessage } = require('./messageHelper.js');
 const { downloadMediaMessage } = require('baileys');
 
 
@@ -105,17 +106,6 @@ function extractContentTypeAndReply(message, messageType) {
   return { content, contentType, reply };
 }
 
-async function isRecentMessage(chatId) {
-  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
-
-  const recentMessage = await Message.find({
-    $or: [{ group_id: chatId }, { numero: chatId }],
-    createdAt: { $gte: fiveMinutesAgo }
-  }).sort({ createdAt: -1 }).limit(1);
-
-  return !!recentMessage;
-}
-
 async function getLastMessages(chatId, n) {
   const messages = await Message.find({ group_id: chatId })
     .sort({ createdAt: -1 })

package/lib/helpers/filesHelper.js

@@ -1,36 +1,41 @@
 const { PDFDocument } = require('pdf-lib');
-const { exec } = require('child_process');
-const fs = require('fs');
+const { execFile } = require('child_process');
+const fs = require('fs').promises;
 const path = require('path');
 const sharp = require('sharp');
 
+const { downloadFileFromS3 } = require('../config/awsConfig.js');
+const { Message } = require('../models/messageModel.js');
+const { sanitizeFilename } = require('../utils/sanitizer.js');
 
 async function convertPdfToImages(pdfName) {
   const outputDir = path.join(__dirname, 'assets', 'tmp');
-  const pdfPath = `${outputDir}/${pdfName}.pdf`;
+  
+  const sanitizedName = sanitizeFilename(pdfName);
+  const pdfPath = path.join(outputDir, `${sanitizedName}.pdf`);
+  const outputPattern = path.join(outputDir, sanitizedName);
 
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
+  await fs.promises.mkdir(outputDir, { recursive: true });
 
   return new Promise((resolve, reject) => {
-    const command = `pdftoppm -jpeg ${pdfPath} ${outputDir}/${pdfName}`;
-    console.log(command);
-    exec(command, (error, stdout, stderr) => {
+    const args = ['-jpeg', pdfPath, outputPattern];
+    console.log('[convertPdfToImages] Running: pdftoppm', args.join(' '));
+    
+    execFile('pdftoppm', args, (error, stdout, stderr) => {
       if (error) {
-        return reject(`Error splitting PDF: ${stderr}`);
+        return reject(new Error(`Error splitting PDF: ${stderr || error.message}`));
       }
 
       fs.readdir(outputDir, (err, files) => {
         if (err) {
-          return reject(`Error reading output directory: ${err.message}`);
+          return reject(new Error(`Error reading output directory: ${err.message}`));
         }
 
-        const pngFiles = files
-          .filter(file => file.startsWith(pdfName) && file.endsWith('.jpg'))
+        const jpgFiles = files
+          .filter(file => file.startsWith(sanitizedName) && file.endsWith('.jpg'))
           .map(file => path.join(outputDir, file));
 
-        resolve(pngFiles);
+        resolve(jpgFiles);
       });
     });
   });
@@ -43,11 +48,9 @@ async function combineImagesToPDF(config) {
     sortNumerically = true 
   } = config;
   
-  // Get all files in the directory
   const inputDir = path.join(__dirname, 'assets', 'tmp');
   const files = await fs.promises.readdir(inputDir);
     
-  // Filter for image files with the specified extensions
   const imageFiles = files.filter(file => {
     const ext = path.extname(file).toLowerCase().substring(1);
     const hasValidExtension = extensions.includes(ext);
@@ -55,7 +58,6 @@ async function combineImagesToPDF(config) {
     return hasValidExtension && hasPrefix;
   });
   
-  // Sort files
   if (sortNumerically) {
     imageFiles.sort((a, b) => {
       const aMatch = a.match(/\d+/g);
@@ -71,11 +73,9 @@ async function combineImagesToPDF(config) {
   
   console.log(`Found ${imageFiles.length} image files to combine`);
     
-  // Create a new PDF document
   const pdfDoc = await PDFDocument.create();
   const processedFiles = [];
     
-  // Process each image file
   for (const [index, file] of imageFiles.entries()) {
     try {
       const filePath = path.join(inputDir, file);
@@ -89,8 +89,7 @@ async function combineImagesToPDF(config) {
       const { width, height } = await sharp(imageBuffer).metadata();
       const img = await pdfDoc.embedPng(pngBuffer);
       const page = pdfDoc.addPage([width, height]);
-            
-      // Draw the image on the page
+      
       page.drawImage(img, {
         x: 0,
         y: 0,
@@ -112,23 +111,67 @@ async function combineImagesToPDF(config) {
   };
 }
 
-function cleanupFiles(files) {
-  files.forEach(file => {
-    if (fs.existsSync(file)) {
-      try {
-        fs.unlinkSync(file);
-        console.log(`Deleted: ${file}`);
-      } catch (error) {
-        console.error(`Error deleting ${file}:`, error);
+const cleanupFiles = async (files) => {
+  if (!files || files.length === 0) return;
+  
+  await Promise.all(files.map(async (filePath) => {
+    try {
+      await fs.promises.unlink(filePath);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        const safeFileName = filePath ? filePath.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown';
+        console.warn(`[cleanupFiles] Error deleting ${safeFileName}:`, error?.message || String(error));
       }
-    } else {
-      console.warn(`File not found: ${file}`);
     }
+  }));
+  
+  console.log(`[cleanupFiles] Cleaned up ${files.length} files`);
+};
+
+async function downloadMediaAndCreateFile(code, reply) {
+  const resultMedia = await Message.findOne({
+    message_id: reply.message_id,
+    timestamp: reply.timestamp,
+    media: { $ne: null }
   });
+
+  if (!resultMedia) return [];
+
+  if (!resultMedia.media || !resultMedia.media.key) {
+    console.log('[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.promises.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];
+
+  if (subType === 'document' ||  subType === 'application') {
+    await fs.promises.unlink(downloadPath);
+  }
+
+  return fileNames;
 }
 
 module.exports = {
   convertPdfToImages,
   combineImagesToPDF,
-  cleanupFiles
+  cleanupFiles,
+  downloadMediaAndCreateFile
 };

package/lib/helpers/mediaHelper.js

@@ -1,10 +1,11 @@
-const AWS = require('../config/awsConfig.js');
 const path = require('path');
 const fs = require('fs');
+const AWS = require('../config/awsConfig.js');
+const { sanitizeMediaFilename } = require('../utils/sanitizer.js');
 
 async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, contentType, messageType) {
   const extension = getFileExtension(contentType);
-  const sanitizedTitle = titleFile ? sanitizeFileName(titleFile) : '';
+  const sanitizedTitle = titleFile ? sanitizeMediaFilename(titleFile) : '';
   const fileName = sanitizedTitle 
     ? `${messageType}/${messageID}_${sanitizedTitle}.${extension}`
     : `${messageType}/${messageID}.${extension}`;
@@ -58,15 +59,8 @@ function getFileExtension(contentType) {
   return mimeToExt[contentType] || 'bin';
 }
 
-function sanitizeFileName(fileName) {
-  return fileName
-    .replace(/[^a-zA-Z0-9_-]/g, '')
-    .slice(0, 50);
-}
-
 module.exports = {
   uploadMediaToS3,
   saveMediaToLocal,
-  getFileExtension,
-  sanitizeFileName
+  getFileExtension
 };