@peopl-health/nexus 1.1.4 → 1.1.6

package/lib/adapters/BaileysProvider.js

@@ -15,7 +15,7 @@ class BaileysProvider extends MessageProvider {
   async initialize() {
     try {
       const { default: makeWASocket, useMultiFileAuthState } = require('baileys');
-      const { useMongoDBAuthState } = require('../utils/mongoAuthConfig');
+      const { useMongoDBAuthState } = require('../config/mongoAuthConfig');
       const pino = require('pino');
       
       const logger = pino({ level: 'warn' });

package/lib/config/awsConfig.js

@@ -0,0 +1,103 @@
+const AWS = require('aws-sdk');
+const fs = require('fs');
+const path = require('path');
+
+AWS.config.update({
+  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+  region: 'us-east-1',
+  signatureVersion: 'v4'
+});
+
+const s3 = new AWS.S3();
+
+
+async function uploadBufferToS3(buffer, bucketName, key, contentType, isWhatsAppMedia = false) {
+  const params = {
+    Bucket: bucketName,
+    Key: key,
+    Body: buffer,
+    ContentType: contentType,
+    Metadata: isWhatsAppMedia ? {
+      'x-amz-meta-whatsapp': 'true',
+      'x-amz-meta-expiry': new Date(new Date().getTime() + (7 * 24 * 60 * 60 * 1000)).toISOString() // 7 days expiry
+    } : {}
+  };
+
+  try {
+    const data = await s3.upload(params).promise();
+    console.log(`File uploaded successfully at ${data.Location}`);
+    return data.Location;
+  } catch (error) {
+    console.error(`Error uploading file: ${error.message}`);
+    throw error;
+  }
+}
+
+async function downloadFileFromS3(bucketName, key, downloadPath) {
+  console.log(`[S3] Attempting to download file from S3 - Bucket: ${bucketName}, Key: ${key}`);
+    
+  const headParams = {
+    Bucket: bucketName,
+    Key: key
+  };
+    
+  try {
+    await s3.headObject(headParams).promise();
+    console.log(`[S3] Key exists in bucket: ${key}`);
+  } catch (headErr) {
+    console.error(`[S3] Object check failed - Key: ${key}, Error: ${headErr.code} - ${headErr.message}`);
+    if (headErr.code === 'NotFound') {
+      console.log(`[S3] Key does not exist in bucket: ${key}`);
+    }
+    throw headErr;
+  }
+    
+  const params = {
+    Bucket: bucketName,
+    Key: key
+  };
+
+  try {
+    console.log(`[S3] Downloading file data - Key: ${key}`);
+    const data = await s3.getObject(params).promise();
+    console.log(`[S3] Successfully retrieved file - Key: ${key}, ContentType: ${data.ContentType}, Size: ${data.ContentLength} bytes`);
+        
+    if (downloadPath) {
+      const directory = path.dirname(downloadPath);
+      fs.mkdirSync(directory, { recursive: true });
+      fs.writeFileSync(downloadPath, data.Body);
+      console.log(`[S3] File saved to disk at: ${downloadPath}`);
+      return;
+    }
+        
+    return data;
+  } catch (error) {
+    console.error(`[S3] Error downloading file - Key: ${key}, Error: ${error.code} - ${error.message}`);
+    throw error;
+  }
+}
+
+async function generatePresignedUrl(bucketName, key, expiration = 300) {
+  const params = {
+    Bucket: bucketName,
+    Key: key,
+    Expires: expiration
+  };
+
+  try {
+    const url = s3.getSignedUrlPromise('getObject', params);
+    console.log(`Presigned URL generated: ${url}`);
+    return url;
+  } catch (error) {
+    console.error(`Error generating presigned URL: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = {
+  s3,
+  uploadBufferToS3,
+  downloadFileFromS3,
+  generatePresignedUrl
+};

package/lib/config/llmConfig.js

@@ -0,0 +1,4 @@
+// Temporary stub for llmConfig - should be replaced with Nexus LLM provider
+module.exports = {
+  openaiClient: null // This will be replaced with Nexus LLM provider
+};

package/lib/controllers/assistantController.js

@@ -1,30 +1,11 @@
-// Optional config - will be undefined if not available
-let Config_ID;
-try {
-  Config_ID = require('../config/airtableConfig')?.Config_ID;
-} catch (e) {
-  Config_ID = null;
-}
-
-// Optional model imports
-let updateThreadActive, updateThreadStop, Thread;
-try {
-  const threadModel = require('../models/threadModel');
-  updateThreadActive = threadModel.updateThreadActive;
-  updateThreadStop = threadModel.updateThreadStop;
-  Thread = threadModel.Thread;
-} catch (e) {
-  // Models not available
-}
-
-// Optional service imports - stub functions for missing services
-const getRecordByFilter = () => Promise.resolve(null);
-const createAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const addMsgAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const addInsAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const getThreadInfo = () => Promise.resolve(null);
-const switchAssistant = () => Promise.resolve({ success: false, error: 'Service not available' });
-const sendMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
+const { Config_ID } = require('../config/airtableConfig');
+
+const { updateThreadActive, updateThreadStop, Thread } = require('../models/threadModel');
+
+const { getRecordByFilter } = require('../services/airtableService');
+const { createAssistant, addMsgAssistant, addInsAssistant } = require('../services/assistantService');
+const { getThreadInfo, switchAssistant } = require('../services/assistantService');
+const { sendMessage } = require('../core/NexusMessaging');
 
 
 const activeAssistantController = async (req, res) => {
@@ -96,7 +77,7 @@ const createAssistantController = async (req, res) => {
 };
 
 const getInfoAssistantController = async (req, res) => {
-  const { code } = req.query;
+  const { code } = req.body;
 
   try {
     let threadInfo = await getThreadInfo(code);

package/lib/core/NexusMessaging.js

@@ -325,4 +325,18 @@ class NexusMessaging {
   }
 }
 
-module.exports = { NexusMessaging };
+const defaultInstance = new NexusMessaging();
+
+const sendMessage = async (messageData) => {
+  return await defaultInstance.sendMessage(messageData);
+};
+
+const sendScheduledMessage = async (scheduledMessage) => {
+  return await defaultInstance.sendScheduledMessage(scheduledMessage);
+};
+
+module.exports = { 
+  NexusMessaging,
+  sendMessage,
+  sendScheduledMessage
+};

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
+};