@peopl-health/nexus 1.1.5 → 1.1.7

package/lib/helpers/assistantHelper.js

@@ -0,0 +1,292 @@
+const { downloadFileFromS3, generatePresignedUrl } = require('../config/awsConfig.js');
+const { openaiClient } = require('../config/llmConfig.js');
+
+const { LegacyMessage } = require('../models/messageModel.js');
+
+const { convertPdfToImages } = require('./filesHelper.js');
+const { analyzeImage } = require('../helpers/llmsHelper.js');
+
+const { getRecordByFilter } = require('../services/airtableService.js');
+
+const fs = require('fs');
+const path = require('path');
+
+const mode = process.env.NODE_ENV || 'dev';
+
+
+async function checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = 30) {
+  try {
+    const run = await openaiClient.beta.threads.runs.retrieve(thread_id, run_id);
+    console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
+
+    if (run.status === 'failed' || run.status === 'expired' || run.status === 'incomplete') {
+      console.log(`Run failed. ${run.status} `);
+      console.log('Error:');
+      console.log(run);
+      return false;
+    } else if (run.status === 'cancelled') {
+      console.log('cancelled');
+      return true;
+    } else if (run.status === 'requires_action') {
+      console.log('requires_action');
+      if (retryCount < maxRetries) await assistant.handleRequiresAction(run);
+      await new Promise(resolve => setTimeout(resolve, 5000));
+      return checkRunStatus(assistant, thread_id, run_id, maxRetries, maxRetries);
+    } else if (run.status !== 'completed') {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      return checkRunStatus(assistant, thread_id, run_id);
+    } else {
+      console.log('Run completed.');
+      return true;
+    }
+  } catch (error) {
+    console.error('Error checking run status:', error);
+    return false;
+  }
+}
+
+async function checkIfFinished(text) {
+  try {
+    const completion = await openaiClient.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: [
+        {
+          role: 'user', 
+          content: `Dado el siguiente dialogo, determina si el paciente desea finalizar la conversación.
+                    Considera que la conversación ha terminado si el paciente: 1)Agradece o se despide, usando expresiones como 'gracias', 'adiós', 'hasta luego', etc.
+                    2)Indica explícitamente que no tiene más síntomas o preguntas, o que no necesita más ayuda.
+                    3)Expresa que no desea continuar. O el asistente envia recomendaciones o se despide.
+                    Responde solo con 'Si' si la conversación ha terminado, o 'No' si aún continúa: Texto: "${text}`
+        }
+      ]
+    });
+    
+    return completion.choices[0].message.content;
+  } catch (error) {
+    console.error('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 LegacyMessage.find(query).sort({ timestamp: -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 LegacyMessage.updateOne(
+        { message_id: message.message_id, timestamp: message.timestamp },
+        { $set: { processed: true } }
+      );
+    }
+
+    return patientReply.reverse();
+  } catch (error) {
+    console.error('Error getting the last user messages:', error);
+    return [];
+  }
+}
+
+async function getLastNMessages(code, n) {
+  try {
+    const lastMessages = await LegacyMessage.find({ numero: code })
+      .sort({ timestamp: -1 })
+      .limit(n);
+
+    // Format each message and concatenate them with skip lines
+    const formattedMessages = lastMessages
+      .reverse()
+      .map(message => `[${message.timestamp}] ${message.body}`)
+      .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 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 (mode === 'prod') {
+    if (reply.from_me) {
+      role = 'asistente';
+      name = 'Pipo';
+    }
+  }
+  return { role, name };
+};
+
+function formatMessage(reply) {
+  try {
+    return `[${reply.timestamp}] ${reply.body}`;
+  } catch {
+    return null;
+  } 
+}
+
+async function downloadMediaAndCreateFile(code, reply) {
+  const resultMedia = await LegacyMessage.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 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];
+
+  if (subType === 'document' ||  subType === 'application') {
+    await fs.promises.unlink(downloadPath);
+  }
+    
+  console.log(fileNames);
+
+  return fileNames;
+}
+
+async function processMessage(code, reply, thread) {
+  try {
+    const formattedMessage = formatMessage(reply);
+    const isNotAssistant = !reply.from_me;
+    let messagesChat = [];
+    let attachments = [];
+    let url = null;
+
+    if (formattedMessage) {
+      messagesChat.push({ type: 'text', text: formattedMessage });
+    }
+
+    // Handle media if present
+    if (reply.is_media) {
+      console.log('IS MEDIA', reply.is_media);
+      const fileNames = await downloadMediaAndCreateFile(code, reply);
+      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')) {
+          const imageAnalysis = await analyzeImage(fileName);
+          console.log(imageAnalysis);
+          const invalidAnalysis = ['NOT_MEDICAL', 'QUALITY_INSUFFICIENT'];
+          url = await generatePresignedUrl(reply.media.bucketName, reply.media.key);
+          if (imageAnalysis.has_table) {
+            messagesChat.push({
+              type: 'text',
+              text: imageAnalysis.table_data,
+            });
+          } else if (!invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
+            messagesChat.push({
+              type: 'text',
+              text: imageAnalysis.medical_analysis,
+            });
+          } else {
+            console.log('Add attachment');
+            const file = await openaiClient.files.create({
+              file: fs.createReadStream(fileName),
+              purpose: 'vision',
+            });
+            messagesChat.push({
+              type: 'image_file',
+              image_file: { file_id: file.id },
+            });
+          }
+        } else if (fileName.includes('audio')) {
+          const audioTranscript = await openaiClient.audio.transcriptions.create({
+            model: 'whisper-1',
+            file: fs.createReadStream(fileName),
+            response_format: 'text',
+            language: 'es'
+          });
+          console.log('Inside AUDIO', audioTranscript);
+          messagesChat.push({
+            type: 'text',
+            text: audioTranscript,
+          });
+        }
+      }
+    }
+
+    console.log('messagesChat', messagesChat);
+    console.log('attachments', attachments);
+
+    await openaiClient.beta.threads.messages.create(thread.thread_id, {
+      role: 'user',
+      content: messagesChat,
+      attachments: attachments
+    });
+
+    console.log('Formatted message:', formattedMessage);
+
+    await LegacyMessage.updateOne(
+      { message_id: reply.message_id, timestamp: reply.timestamp },
+      { $set: { assistant_id: thread.assistant_id, thread_id: thread.thread_id } }
+    );
+
+    return {isNotAssistant, url};
+  } catch (err) {
+    console.log(`Error inside process message ${err}`);
+  }
+}
+
+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})`);
+  }
+}
+
+module.exports = {
+  checkRunStatus,
+  checkIfFinished,
+  getLastMessages,
+  getLastNMessages,
+  getPatientRoleAndName,
+  getCurRow,
+  formatMessage,
+  downloadMediaAndCreateFile,
+  processMessage
+};

package/lib/helpers/baileysHelper.js

@@ -0,0 +1,149 @@
+const { LegacyMessage, insertMessage, getMessageValues } = require('../models/messageModel.js');
+const { uploadMediaToS3 } = require('./mediaHelper.js');
+const { downloadMediaMessage } = require('baileys');
+
+
+async function processMessage(message, messageType) {
+  try {
+    const { content, reply } = extractMessageContent(message, messageType);
+    if (content != null && content < 1) return;
+
+    const values = getMessageValues(message, content, reply, false);
+    await insertMessage(values);
+
+    return values;
+  } catch (error) {
+    console.log('Failed to process message: %s', error.stack);
+    throw error;
+  }
+}
+
+async function processMediaMessage(message, logger, messageType, bucketName, sock) {
+  try {
+    const { content, contentType, reply } = extractContentTypeAndReply(message, messageType);
+    let values = getMessageValues(message, content, reply, true);
+    // Insert message into the message database
+
+    const messageID = message.key.id;
+    const mediaBuffer = await downloadMedia(message, logger, sock);
+    let titleFile = await extractMessageTitle(message, messageType);
+    titleFile = titleFile?.trim().replace(/\s+/g, '') || '';
+    const key = await uploadMediaToS3(mediaBuffer, messageID, titleFile, bucketName, contentType, messageType);
+    const valuesMedia = {contentType: contentType, 
+      bucketName: bucketName, 
+      key: key};
+    values['media'] = valuesMedia;
+        
+    await insertMessage(values);
+
+    return values;
+  } catch (error) {
+    console.log('Failed to process message: %s', error.stack);
+    throw error;
+  }
+}
+
+function extractMessageContent(message, messageType) {
+  let content = null;
+  let reply = null;
+  switch (messageType) {
+  case 'conversation':
+    content = message.message.conversation;
+    break;
+  case 'extendedTextMessage':
+    content = message.message.extendedTextMessage.text;
+    if (message.message.extendedTextMessage.contextInfo != null) {
+      reply = message.message.extendedTextMessage.contextInfo.stanzaId;
+    }
+    break;
+  }
+  return { content, reply };
+}
+
+function extractMessageTitle(message, messageType) {
+  switch (messageType) {
+  case 'documentMessage':
+    return message.message.documentMessage.title;
+  case 'documentWithCaptionMessage':
+    return message.message.documentWithCaptionMessage.message.documentMessage.title;
+  default:
+    return null;
+  }
+}
+
+function extractContentTypeAndReply(message, messageType) {
+  let submessage = null;
+  switch (messageType) {
+  case 'imageMessage':
+    submessage = message.message.imageMessage;
+    break;
+  case 'audioMessage':
+    submessage = message.message.audioMessage;
+    break;
+  case 'videoMessage':
+    submessage = message.message.videoMessage;
+    break;
+  case 'documentMessage':
+    submessage = message.message.documentMessage;
+    break;
+  case 'documentWithCaptionMessage':
+    submessage = message.message.documentWithCaptionMessage.message.documentMessage;
+    break;
+  default:
+    break;
+  }
+
+  const content = submessage.caption;
+  const contentType = submessage.mimetype;
+  const reply = submessage.contextInfo ? submessage.contextInfo.stanzaId : null;
+
+  return { content, contentType, reply };
+}
+
+async function isRecentMessage(chatId) {
+  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+
+  const recentMessage = await LegacyMessage.find({
+    $or: [{ group_id: chatId }, { numero: chatId }],
+    timestamp: { $gte: fiveMinutesAgo.toISOString() }
+  }).sort({ timestamp: -1 }).limit(1);
+
+  return !!recentMessage;
+}
+
+async function getLastMessages(chatId, n) {
+  const messages = await LegacyMessage.find({ group_id: chatId })
+    .sort({ timestamp: -1 })
+    .limit(n)
+    .select('timestamp numero nombre_whatsapp body');
+
+  return messages.map(msg => `[${msg.timestamp}] ${msg.numero} ${msg.nombre_whatsapp}: ${msg.body}`);
+}
+
+async function downloadMedia(message, logger, sock) {
+  try {
+    const buffer = await downloadMediaMessage(
+      message,
+      'buffer',
+      {},
+      {
+        logger,
+        reuploadRequest: sock.updateMediaMessage,
+      }
+    );
+    return buffer;
+  } catch (error) {
+    console.log('Failed to download media:', error.stack);
+    throw error;
+  }
+}
+
+
+module.exports = {
+  extractMessageContent,
+  processMessage,
+  processMediaMessage,
+  isRecentMessage,
+  getLastMessages,
+  downloadMedia
+};

package/lib/helpers/filesHelper.js

@@ -0,0 +1,134 @@
+const { PDFDocument } = require('pdf-lib');
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const sharp = require('sharp');
+
+
+async function convertPdfToImages(pdfName) {
+  const outputDir = path.join(__dirname, 'assets', 'tmp');
+  const pdfPath = `${outputDir}/${pdfName}.pdf`;
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    const command = `pdftoppm -jpeg ${pdfPath} ${outputDir}/${pdfName}`;
+    console.log(command);
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        return reject(`Error splitting PDF: ${stderr}`);
+      }
+
+      fs.readdir(outputDir, (err, files) => {
+        if (err) {
+          return reject(`Error reading output directory: ${err.message}`);
+        }
+
+        const pngFiles = files
+          .filter(file => file.startsWith(pdfName) && file.endsWith('.jpg'))
+          .map(file => path.join(outputDir, file));
+
+        resolve(pngFiles);
+      });
+    });
+  });
+}
+
+async function combineImagesToPDF(config) {
+  const { 
+    code, 
+    extensions = ['jpg', 'jpeg', 'png', 'tiff'], 
+    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);
+    const hasPrefix = code ? file.startsWith(code) : true;
+    return hasValidExtension && hasPrefix;
+  });
+  
+  // Sort files
+  if (sortNumerically) {
+    imageFiles.sort((a, b) => {
+      const aMatch = a.match(/\d+/g);
+      const bMatch = b.match(/\d+/g);
+            
+      if (!aMatch || !bMatch) return a.localeCompare(b);
+            
+      return parseInt(aMatch[0]) - parseInt(bMatch[0]);
+    });
+  } else {
+    imageFiles.sort();
+  }
+  
+  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);
+      console.log(`Processing file ${index + 1}/${imageFiles.length}: ${file}`);
+            
+      const imageBuffer = await fs.promises.readFile(filePath);
+      const pngBuffer = await sharp(imageBuffer)
+        .toFormat('png')
+        .toBuffer();
+            
+      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,
+        width: width,
+        height: height,
+      });
+
+      processedFiles.push(filePath);
+    } catch (error) {
+      console.error(`Error processing file ${file}:`, error);
+    }
+  }
+    
+  console.log('Combined PDF created successfully');
+    
+  return {
+    pdfBuffer: await pdfDoc.save(),
+    processedFiles
+  };
+}
+
+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);
+      }
+    } else {
+      console.warn(`File not found: ${file}`);
+    }
+  });
+}
+
+module.exports = {
+  convertPdfToImages,
+  combineImagesToPDF,
+  cleanupFiles
+};