@peopl-health/nexus 1.1.1 → 1.1.3

package/README.md

@@ -231,52 +231,8 @@ const { setupDefaultRoutes } = require('@peopl-health/nexus');
 
 const app = express();
 
-// Define your controllers
-const myControllers = {
-  // Assistant controllers
-  activeAssistantController: (req, res) => { /* your logic */ },
-  createAssistantController: (req, res) => { /* your logic */ },
-  listAssistantController: (req, res) => { /* your logic */ },
-  addInsAssistantController: (req, res) => { /* your logic */ },
-  addMsgAssistantController: (req, res) => { /* your logic */ },
-  getInfoAssistantController: (req, res) => { /* your logic */ },
-  switchAssistantController: (req, res) => { /* your logic */ },
-  stopAssistantController: (req, res) => { /* your logic */ },
-  
-  // Conversation controllers
-  getConversationController: (req, res) => { /* your logic */ },
-  searchConversationsController: (req, res) => { /* your logic */ },
-  getConversationsByNameController: (req, res) => { /* your logic */ },
-  getConversationMessagesController: (req, res) => { /* your logic */ },
-  getNewMessagesController: (req, res) => { /* your logic */ },
-  getConversationReplyController: (req, res) => { /* your logic */ },
-  sendTemplateToNewNumberController: (req, res) => { /* your logic */ },
-  markMessagesAsReadController: (req, res) => { /* your logic */ },
-  
-  // Media controllers
-  getMediaController: (req, res) => { /* your logic */ },
-  handleFileUpload: (req, res) => { /* your logic */ },
-  
-  // Message controllers
-  sendMessageController: (req, res) => { /* your logic */ },
-  sendBulkMessageController: (req, res) => { /* your logic */ },
-  sendBulkMessageAirtableController: (req, res) => { /* your logic */ },
-  
-  // Template controllers
-  createTemplate: (req, res) => { /* your logic */ },
-  listTemplates: (req, res) => { /* your logic */ },
-  getPredefinedTemplates: (req, res) => { /* your logic */ },
-  getTemplate: (req, res) => { /* your logic */ },
-  getCompleteTemplate: (req, res) => { /* your logic */ },
-  createFlow: (req, res) => { /* your logic */ },
-  deleteFlow: (req, res) => { /* your logic */ },
-  submitForApproval: (req, res) => { /* your logic */ },
-  checkApprovalStatus: (req, res) => { /* your logic */ },
-  deleteTemplate: (req, res) => { /* your logic */ }
-};
-
-// Setup all default routes with one line
-setupDefaultRoutes(app, myControllers);
+// Setup all default routes with built-in controllers (one line!)
+setupDefaultRoutes(app);
 
 // Add your custom routes
 app.get('/api/custom', myCustomController);

package/examples/basic-usage.js

@@ -1,6 +1,10 @@
-const { Nexus } = require('@peopl/nexus');
+const { Nexus, setupDefaultRoutes } = require('@peopl/nexus');
+const express = require('express');
 require('dotenv').config();
 
+const app = express();
+app.use(express.json());
+
 async function main() {
   const nexus = new Nexus();
 
@@ -14,6 +18,9 @@ async function main() {
       }
     });
 
+    // Setup all default routes (no controllers needed!)
+    setupDefaultRoutes(app);
+
     // Set up handlers with minimal code
     nexus.setHandlers({
       onMessage: async (messageData) => {
@@ -37,7 +44,16 @@ async function main() {
       }
     });
 
-    console.log('Nexus started - send messages to test');
+    // Webhook endpoint
+    app.post('/webhook', async (req, res) => {
+      await nexus.processMessage(req.body);
+      res.sendStatus(200);
+    });
+
+    const PORT = process.env.PORT || 3000;
+    app.listen(PORT, () => {
+      console.log(`Nexus server running on port ${PORT}`);
+    });
     
   } catch (error) {
     console.error('Error:', error);

package/lib/config/airtableConfig.js

@@ -0,0 +1,45 @@
+const Airtable = require('airtable');
+
+const airtableConfig = {
+  apiKey: process.env.AIRTABLE_API_KEY,
+};
+
+// Configurable base IDs - users can override via environment variables
+const Calendar_ID = process.env.AIRTABLE_CALENDAR_ID || 'appIjEstWR6972tbF';
+const Config_ID = process.env.AIRTABLE_CONFIG_ID || 'app9K4EvGI8McC8jF';
+const Historial_Clinico_ID = process.env.AIRTABLE_HISTORIAL_CLINICO_ID || 'appdUpGUS06XIzVnY';
+const Logging_ID = process.env.AIRTABLE_LOGGING_ID || 'appQ7YhzfebRDbSPJ';
+const Monitoreo_ID = process.env.AIRTABLE_MONITOREO_ID || 'appdvraKSdp0XVn5n';
+const Programa_Juntas_ID = process.env.AIRTABLE_PROGRAMA_JUNTAS_ID || 'appKFWzkcDEWlrXBE';
+const Symptoms_ID = process.env.AIRTABLE_SYMPTOMS_ID || 'appQRhZlQ9tMfYZWJ';
+const Webinars_Leads_ID = process.env.AIRTABLE_WEBINARS_LEADS_ID || 'appzjpVXTI0TgqGPq';
+
+// Initialize Airtable only if API key is provided
+let airtable = null;
+if (airtableConfig.apiKey) {
+  airtable = new Airtable({ apiKey: airtableConfig.apiKey });
+}
+
+module.exports = {
+  airtable,
+  config: airtableConfig,
+  Calendar_ID,
+  Config_ID,
+  Historial_Clinico_ID,
+  Logging_ID,
+  Monitoreo_ID,
+  Programa_Juntas_ID,
+  Symptoms_ID,
+  Webinars_Leads_ID,
+  
+  // Helper function to get base by ID
+  getBase: (baseId = process.env.AIRTABLE_BASE_ID) => {
+    if (!airtable) {
+      throw new Error('Airtable not configured. Please set AIRTABLE_API_KEY environment variable.');
+    }
+    if (!baseId) {
+      throw new Error('Airtable base ID not provided. Please set AIRTABLE_BASE_ID environment variable or pass baseId parameter.');
+    }
+    return airtable.base(baseId);
+  }
+};

package/lib/{utils → config}/mongoAuthConfig.js

@@ -1,11 +1,6 @@
 const { MongoClient } = require('mongodb');
 
-let baileys;
-try {
-  baileys = require('baileys');
-} catch (error) {
-  baileys = null;
-}
+const { proto, Curve, signedKeyPair, generateRegistrationId } = require('baileys');
 const { randomBytes } = require('crypto');
 
 async function connectToMongo(mongoClient) {
@@ -19,11 +14,6 @@ async function connectToMongo(mongoClient) {
 }
 
 async function initAuthCreds() {
-  if (!baileys) {
-    throw new Error('Baileys is required for auth credentials but not installed');
-  }
-  
-  const { proto, Curve, signedKeyPair, generateRegistrationId } = baileys;
   const identityKey = Curve.generateKeyPair();
   return {
     noiseKey: Curve.generateKeyPair(),
@@ -120,8 +110,8 @@ async function useMongoDBAuthState(uri, dbName, sessionId) {
           const data = {};
           await Promise.all(ids.map(async (id) => {
             let value = await readData(`${type}-${id}`);
-            if (type === 'app-state-sync-key' && baileys) {
-              value = baileys.proto.Message.AppStateSyncKeyData.fromObject(value);
+            if (type === 'app-state-sync-key') {
+              value = proto.Message.AppStateSyncKeyData.fromObject(data);
             }
             data[id] = value;
           }));

package/lib/controllers/assistantController.js

@@ -17,28 +17,14 @@ try {
   // Models not available
 }
 
-// Optional service imports
-let getRecordByFilter, createAssistant, addMsgAssistant, addInsAssistant, getThreadInfo, switchAssistant, sendMessage;
-try {
-  getRecordByFilter = require('../services/airtableService')?.getRecordByFilter;
-} catch (e) {
-  // Service not available
-}
-try {
-  const assistantService = require('../services/assistantService');
-  createAssistant = assistantService.createAssistant;
-  addMsgAssistant = assistantService.addMsgAssistant;
-  addInsAssistant = assistantService.addInsAssistant;
-  getThreadInfo = assistantService.getThreadInfo;
-  switchAssistant = assistantService.switchAssistant;
-} catch (e) {
-  // Service not available
-}
-try {
-  sendMessage = require('../services/whatsappService')?.sendMessage;
-} catch (e) {
-  // Service 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 activeAssistantController = async (req, res) => {

package/lib/controllers/conversationController.js

@@ -1,6 +1,6 @@
 const { Message } = require('../models/messageModel');
-const { sendMessage } = require('../services/whatsappService');
 const { fetchConversationData, processConversations } = require('../services/conversationService');
+const { sendMessage } = require('../core/NexusMessaging');  
 
 const getConversationController = async (req, res) => {
   const startTime = Date.now();

package/lib/controllers/messageController.js

@@ -1,7 +1,17 @@
-const { ScheduledMessage } = require('../models/agendaMessageModel.js');
+// Import from Nexus core
+const { sendMessage } = require('../core/NexusMessaging');
+
+// Stub for missing model
+const ScheduledMessage = {
+  create: () => Promise.resolve({ success: false, error: 'Model not available' }),
+  find: () => Promise.resolve([]),
+  findById: () => Promise.resolve(null),
+  deleteOne: () => Promise.resolve({ success: false, error: 'Model not available' })
+};
 
-const { getRecordByFilter } = require('../services/airtableService.js');
-const { sendScheduledMessage } = require('../services/whatsappService.js');
+// Stub functions for missing services
+const getRecordByFilter = () => Promise.resolve(null);
+const sendScheduledMessage = () => Promise.resolve({ success: false, error: 'Service not available' });
 
 const moment = require('moment-timezone');
 
@@ -21,7 +31,7 @@ const sendMessageController = async (req, res) => {
   const sendMoment = sendTime ? moment.tz(sendTime, timeZone) + 2500 : new Date();
 
   try {
-    const scheduledMessage = new ScheduledMessage({
+    const messageData = {
       fileUrl,
       message,
       fileType,
@@ -33,14 +43,16 @@ const sendMessageController = async (req, res) => {
       author,
       extraDelay: 0,
       variables
-    });
-    await scheduledMessage.save();
-    console.log(scheduledMessage);
-    const sentMessage = await sendScheduledMessage(scheduledMessage);
-    res.status(200).json({ 
-      status: 200, 
-      response: 'Message scheduled to be sent once!',
-      messageId: sentMessage ? sentMessage.sid : null
+    };
+    await ScheduledMessage.create(messageData);
+    console.log('Sending message with data:', messageData);
+    
+    const result = await sendMessage(messageData);
+    
+    res.status(200).json({
+      success: true,
+      message: 'Message sent successfully',
+      messageId: result?.sid || result?.id
     });
   } catch (err) {
     console.error('Error scheduling individual message:', err.message);

package/lib/controllers/templateController.js

@@ -1,11 +1,23 @@
-const TwilioService = require('../services/twilioService');
-const { handleApiError } = require('../utils/errorHandler');
+// Stub functions for missing services
+const TwilioService = {
+  createTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
+  deleteTemplate: () => Promise.resolve({ success: false, error: 'Service not available' }),
+  listTemplates: () => Promise.resolve([]),
+  getTemplate: () => Promise.resolve(null)
+};
+const handleApiError = (res, error, message) => {
+  console.error(message, error);
+  return res.status(500).json({ success: false, error: message });
+};
 
-// Import flow functions from templateFlowController
-const { createFlow, deleteFlow } = require('./templateFlowController');
-const { Template } = require('../templates/templateStructure');
-const TemplateModel = require('../models/templateModel');
-const predefinedTemplates = require('../templates/predefinedTemplates');
+// Stub imports for missing dependencies
+const Template = class { constructor() {} };
+const TemplateModel = {
+  create: () => Promise.resolve({ success: false, error: 'Model not available' }),
+  find: () => Promise.resolve([]),
+  findById: () => Promise.resolve(null)
+};
+const predefinedTemplates = [];
 
 /**
  * Create a new template and store it in both Twilio and our database
@@ -616,6 +628,15 @@ const getCompleteTemplate = async (req, res) => {
   }
 };
 
+// Flow functions (inline since templateFlowController was removed)
+const createFlow = async (req, res) => {
+  return res.status(501).json({ success: false, error: 'Flow creation not available' });
+};
+
+const deleteFlow = async (req, res) => {
+  return res.status(501).json({ success: false, error: 'Flow deletion not available' });
+};
+
 module.exports = {
   createTemplate,
   listTemplates,
@@ -625,7 +646,6 @@ module.exports = {
   checkApprovalStatus,
   deleteTemplate,
   getCompleteTemplate,
-  // Flow functions from templateFlowController
   createFlow,
   deleteFlow
 };

package/lib/routes/index.js

@@ -64,13 +64,64 @@ const createRouter = (routeDefinitions, controllers) => {
   return router;
 };
 
-// Helper function to setup all default routes with provided controllers
-const setupDefaultRoutes = (app, controllers) => {
-  app.use('/api/assistant', createRouter(assistantRouteDefinitions, controllers));
-  app.use('/api/conversation', createRouter(conversationRouteDefinitions, controllers));
-  app.use('/api/media', createRouter(mediaRouteDefinitions, controllers));
-  app.use('/api/message', createRouter(messageRouteDefinitions, controllers));
-  app.use('/api/template', createRouter(templateRouteDefinitions, controllers));
+// Import built-in controllers
+const assistantController = require('../controllers/assistantController');
+const conversationController = require('../controllers/conversationController');
+const mediaController = require('../controllers/mediaController');
+const messageController = require('../controllers/messageController');
+const templateController = require('../controllers/templateController');
+
+// Built-in controllers mapping
+const builtInControllers = {
+  // Assistant controllers
+  activeAssistantController: assistantController.activeAssistantController,
+  addInsAssistantController: assistantController.addInsAssistantController,
+  addMsgAssistantController: assistantController.addMsgAssistantController,
+  createAssistantController: assistantController.createAssistantController,
+  getInfoAssistantController: assistantController.getInfoAssistantController,
+  listAssistantController: assistantController.listAssistantController,
+  switchAssistantController: assistantController.switchAssistantController,
+  stopAssistantController: assistantController.stopAssistantController,
+  
+  // Conversation controllers
+  getConversationController: conversationController.getConversationController,
+  searchConversationsController: conversationController.searchConversationsController,
+  getConversationsByNameController: conversationController.getConversationsByNameController,
+  getConversationMessagesController: conversationController.getConversationMessagesController,
+  getNewMessagesController: conversationController.getNewMessagesController,
+  getConversationReplyController: conversationController.getConversationReplyController,
+  sendTemplateToNewNumberController: conversationController.sendTemplateToNewNumberController,
+  markMessagesAsReadController: conversationController.markMessagesAsReadController,
+  
+  // Media controllers
+  getMediaController: mediaController.getMediaController,
+  handleFileUpload: mediaController.handleFileUpload,
+  
+  // Message controllers
+  sendMessageController: messageController.sendMessageController,
+  sendBulkMessageController: messageController.sendBulkMessageController,
+  sendBulkMessageAirtableController: messageController.sendBulkMessageAirtableController,
+  
+  // Template controllers
+  createTemplate: templateController.createTemplate,
+  listTemplates: templateController.listTemplates,
+  getPredefinedTemplates: templateController.getPredefinedTemplates,
+  getTemplate: templateController.getTemplate,
+  getCompleteTemplate: templateController.getCompleteTemplate,
+  createFlow: templateController.createFlow,
+  deleteFlow: templateController.deleteFlow,
+  submitForApproval: templateController.submitForApproval,
+  checkApprovalStatus: templateController.checkApprovalStatus,
+  deleteTemplate: templateController.deleteTemplate
+};
+
+// Helper function to setup all default routes using built-in controllers
+const setupDefaultRoutes = (app) => {
+  app.use('/api/assistant', createRouter(assistantRouteDefinitions, builtInControllers));
+  app.use('/api/conversation', createRouter(conversationRouteDefinitions, builtInControllers));
+  app.use('/api/media', createRouter(mediaRouteDefinitions, builtInControllers));
+  app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
+  app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
 };
 
 module.exports = {

package/lib/services/airtableService.js

@@ -0,0 +1,82 @@
+const { airtable } = require('../config/airtableConfig');
+
+
+async function addRecord(baseID, tableName, fields) {
+  try {
+    const base = airtable.base(baseID);
+    const record = await base(tableName).create(fields);
+    console.log('Record added at', tableName);
+    return record;
+  } catch (error) {
+    console.error('Error adding record:', error);
+    throw error; 
+  }
+}
+
+
+async function getRecords(baseID, tableName) {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      maxRecords: 3
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error('Error fetching records:', error);
+  }
+}
+
+
+async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view') {
+  try {
+    const records = [];
+    const base = airtable.base(baseID);
+    await base(tableName).select({
+      filterByFormula: `${filter}`,
+      view: view
+    }).eachPage((pageRecords, fetchNextPage) => {
+      pageRecords.forEach(record => {
+        records.push(record.fields);
+      });
+      fetchNextPage();
+    });
+    return records;
+  } catch (error) {
+    console.error(`Error fetching records by ${filter}:`, error);
+  }
+}
+
+
+async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
+  try {
+    const base = airtable.base(baseID);
+    const updatedRecords = [];
+        
+    await base(tableName).select({
+      filterByFormula: `${filter}`
+    }).eachPage(async (pageRecords, fetchNextPage) => {
+      for (const record of pageRecords) {
+        const updatedRecord = await base(tableName).update(record.id, updateFields);
+        updatedRecords.push(updatedRecord);
+      }
+      fetchNextPage();
+    });
+        
+    return updatedRecords;
+  } catch (error) {
+    console.error(`Error updating records by ${filter}:`, error);
+  }
+}
+
+module.exports = {
+  addRecord,
+  getRecords,
+  getRecordByFilter,
+  updateRecordByFilter
+};

package/lib/services/appointmentService.js

@@ -0,0 +1,55 @@
+const { Calendar_ID } = require('../config/airtableConfig.js');
+
+const { ISO_DATE, parseStartTime, addDays } = require('../utils/dateUtils.js');
+const { dateAndTimeFromStart } = require('../utils/dateUtils.js');
+
+const { getRecordByFilter, updateRecordByFilter } = require('../services/airtableService.js');
+
+
+const getNextAppointmentForPatient = async (name, after = new Date()) => {
+  const filter = `AND(patient_name = "${name}", start_time >= '${ISO_DATE(after)}')`;
+  const rows   = await getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+  if (!rows?.length) return null;
+  return rows.sort((a, b) => new Date(a.start_time) - new Date(b.start_time))[0];
+};
+
+const getAppointmentsBetween = async (start, end) => {
+  const filter = `AND(start_time >= '${ISO_DATE(start)}', start_time < '${ISO_DATE(end)}')`;
+  return getRecordByFilter(Calendar_ID, 'calendar_quimio', filter);
+};
+
+const updateAppointmentById = async (recordId, data) => {
+  return updateRecordByFilter(
+    Calendar_ID,
+    'calendar_quimio',
+    `REGEX_MATCH({record_id}, '${recordId}')`,
+    data
+  );
+};
+
+const buildAvailabilityWindow = async originalDate => {
+  const start = addDays(originalDate, 1);
+  const end = addDays(originalDate, 7);
+  
+  const allSlots = await getAppointmentsBetween(start, addDays(end, 1));
+  const availableSlots = allSlots.filter(row => !row.patient);
+  
+  const result = {};
+  availableSlots.forEach(row => {
+    const { date, time } = dateAndTimeFromStart(row.start_time);
+    if (!result[date]) result[date] = [];
+    result[date].push({ time, availableSpots: 1 });
+  });
+  
+  return result;
+};
+
+const parseStart = parseStartTime;
+
+module.exports = {
+  getNextAppointmentForPatient,
+  getAppointmentsBetween,
+  updateAppointmentById,
+  parseStart,
+  buildAvailabilityWindow
+};

package/lib/services/assistantService.js

@@ -0,0 +1,296 @@
+const { Historial_Clinico_ID } = require('../config/airtableConfig.js');
+const { SALES_ASST, QUMIO_REMINDERS_ASST, DOCTOR_SCHEDULE_ASST, PATIENT_SCHEDULE_ASST } = require('../config/assistantConfig.js');
+const { openaiClient } = require('../config/llmConfig.js');
+
+const { Message, formatTimestamp } = require('../models/messageModel.js');
+const { Thread } = require('../models/threadModel.js');
+
+const { checkRunStatus, getCurRow } = require('../helpers/assistantHelper.js');
+const { processMessage, getLastMessages } = require('../helpers/assistantHelper.js');
+const { delay } = require('../helpers/whatsappHelper.js');
+
+const { GeneralAssistant } = require('../assistants/generalAssistant.js');
+const { SalesAssistant } = require('../assistants/salesAssistant.js');
+const { QumioRemindersAssistant } = require('../assistants/qumioRemindersAssistant.js');
+const { DoctorScheduleAssistant } = require('../assistants/doctorScheduleAssistant.js');
+const { PatientScheduleAssistant } = require('../assistants/patientScheduleAssistant.js');
+
+
+const getAssistantById = (assistant_id, thread) => {
+  switch (assistant_id) {
+  case SALES_ASST:
+    return new SalesAssistant(thread);
+  case QUMIO_REMINDERS_ASST:
+    return new QumioRemindersAssistant(thread);
+  case DOCTOR_SCHEDULE_ASST:
+    return new DoctorScheduleAssistant(thread);
+  case PATIENT_SCHEDULE_ASST:
+    return new PatientScheduleAssistant(thread);
+  default:
+    return new GeneralAssistant(thread);
+  }
+};
+
+
+const createAssistant = async (code, assistant_id, messages=[], prevThread=null) => {
+  // If thread already exists, update it
+  const findThread = await Thread.findOne({ code: code });
+  if (findThread) {
+    await Thread.updateOne({ code: code }, { $set: { active: true, stopped: false, assistant_id: assistant_id } });
+    return findThread;
+  }
+  
+  const curRow = await getCurRow(Historial_Clinico_ID, code);
+  console.log('curRow', curRow[0]);
+  const nombre = curRow?.[0]?.['name'] || null;
+  const patientId = curRow?.[0]?.['record_id'] || null;
+
+  const assistant = getAssistantById(assistant_id, null);
+  const initialThread = await assistant.create(code, curRow[0]);
+
+  // Add new messages to memory
+  for (const message of messages) {
+    await openaiClient.beta.threads.messages.create(
+      initialThread.id, { role: 'assistant', content: message }
+    );
+  }
+    
+  // Define new thread data
+  const thread = {
+    code: code,
+    assistant_id: assistant_id,
+    thread_id: initialThread.id,
+    patient_id: patientId,
+    run_id: null,
+    nombre: nombre,
+    active: true
+  };
+
+  const condition = { thread_id: prevThread?.thread_id };
+  const options = { new: true, upsert: true };
+  const updatedThread = await Thread.findOneAndUpdate(condition, thread, options);
+  console.log('Updated thread:', updatedThread);
+
+  // Delete previous thread
+  if (prevThread) {
+    await openaiClient.beta.threads.del(prevThread.thread_id);
+  }
+
+  return thread;
+};
+
+const addMsgAssistant = async (code, inMessages, reply = false) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log(thread);
+    if (thread === null) return null;
+
+    for (const message of inMessages) {
+      console.log(message);
+      await openaiClient.beta.threads.messages.create(
+        thread.thread_id, { role: 'assistant', content: message }
+      );
+    }
+
+    if (!reply) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, 
+      { 
+        assistant_id: thread.assistant_id
+      }
+    );
+
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    await checkRunStatus(assistant, run.thread_id, run.id);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    const ans = messages.data[0].content[0].text.value;
+    console.log('THE ANS IS', ans);
+        
+    return ans;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const addInsAssistant = async (code, instruction) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log(thread);
+    if (thread === null) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, { 
+        assistant_id: thread.assistant_id,
+        additional_instructions: instruction,
+        additional_messages: [
+          { role: 'user', content: instruction }
+        ]
+      }
+    );
+
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    await checkRunStatus(assistant, run.thread_id, run.id);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    console.log(messages.data[0].content);
+    const ans = messages.data[0].content[0].text.value;
+        
+    return ans;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const getThread = async (code, message = null) => {
+  try {
+    let thread = await Thread.findOne({ code: code });
+    console.log('GET THREAD');
+    console.log(thread);
+
+    if (thread === null) {
+      if (message != null) {
+        const timestamp = formatTimestamp(message.messageTimestamp);
+        await Message.updateOne({ message_id: message.key.id, timestamp: timestamp }, { $set: { processed: true } });
+        
+      }
+      return null;
+    }
+
+    while (thread && thread.run_id) {
+      console.log(`Wait for ${thread.run_id} to be executed`);
+      const run = await openaiClient.beta.threads.runs.retrieve(thread.thread_id, thread.run_id);
+      if (run.status === 'cancelled' || run.status === 'expired' || run.status === 'completed') {
+        await Thread.updateOne({ code: code }, { $set: { run_id: null } });
+      }
+      thread = await Thread.findOne({ code: code, active: true });
+      await delay(5000);
+    }
+
+    return thread;
+  } catch (error) {
+    console.error('Error in getThread:', error.message || error);
+    return null;
+  }
+};
+
+const getThreadInfo = async (code) => {
+  try {
+    let thread = await Thread.findOne({ code: code, active: true });
+    return thread;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const replyAssistant = async function (code, message_ = null, thread_ = null, runOptions = {}) {
+  try {
+    let thread = thread_ || await getThread(code);
+    console.log('THREAD STOPPED', code, thread?.active);
+    if (!thread || !thread.active) return null;
+
+    const patientReply = message_ ? [message_] : await getLastMessages(code);
+    console.log('UNREAD DATA', patientReply);
+    if (!patientReply) {
+      console.log('No relevant data found for this assistant.');
+      return null;
+    }
+
+    let activeRuns = await openaiClient.beta.threads.runs.list(thread.thread_id);
+    console.log('ACTIVE RUNS:', activeRuns.length);
+    while (activeRuns.length > 0) {
+      console.log(`ACTIVE RUNS ${thread.thread_id}`);
+      activeRuns = await openaiClient.beta.threads.runs.list(thread.thread_id);
+      await delay(5000);
+    }
+
+    let patientMsg = false;
+    let urls = [];
+    for (const reply of patientReply) {
+      const { isNotAssistant, url } = await processMessage(code, reply, thread);
+      console.log(`isNotAssistant ${isNotAssistant} ${url}`);
+      patientMsg = patientMsg || isNotAssistant;
+      if (url) urls.push({ 'url': url });
+    }
+       
+    if (urls.length > 0) {
+      console.log('urls', urls);
+      /*for (const url of urls) {
+        console.log("url", url);
+        await addRecord(Monitoreo_ID, 'estudios', [{"fields": {"estudios": urls, 
+          "combined_estudios": [ { "url": url} ], "patient_id": [thread.patient_id]}}]);
+      }
+      const { pdfBuffer, processedFiles } = await combineImagesToPDF(code);
+      console.log("AFTER COMBINED IN BUFFER", processedFiles);
+      const key = `${code}-${Date.now()}-combined.pdf`;
+      await AWS.uploadBufferToS3(pdfBuffer, bucketName, key, "application/pdf");
+      const url = await AWS.generatePresignedUrl(bucketName, key);
+      console.log("New record", {"estudios": urls, "combined_estudios": 
+        [ { "url": url} ], "patient_id": [thread.patient_id]});
+      await addRecord(Monitoreo_ID, 'estudios', [{"fields": {"estudios": urls, 
+        "combined_estudios": [ { "url": url} ], "patient_id": [thread.patient_id]}}]);
+      await cleanupFiles(processedFiles);*/
+    }
+
+    thread = await getThread(code);
+    console.log('THREAD STOPPED', code, thread?.stopped);
+    if (!patientMsg || !thread || thread?.stopped) return null;
+
+    const assistant = getAssistantById(thread.assistant_id, thread);
+    const run = await openaiClient.beta.threads.runs.create(
+      thread.thread_id, 
+      { 
+        assistant_id: thread.assistant_id,
+        ...runOptions
+      }
+    );
+    console.log('RUN LAST ERROR:', run.last_error);
+
+    assistant.set_replies(patientReply);
+        
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: run.id } });  
+    const runStatus = await checkRunStatus(assistant, run.thread_id, run.id);
+    console.log('RUN STATUS', runStatus);
+    await Thread.updateOne({ code: thread.code, active: true }, { $set: { run_id: null } });  
+
+    const messages = await openaiClient.beta.threads.messages.list(run.thread_id, { run_id: run.id });
+    const reply = messages.data?.[0]?.content?.[0]?.text?.value || '';
+    console.log(reply);
+
+    return reply;
+  } catch (err) {
+    console.log(`Error inside reply assistant ${err} ${code}`);
+  }
+}; 
+
+const switchAssistant = async (code, assistant_id) => {
+  try {
+    const thread = await Thread.findOne({ code: code });
+    console.log('Inside thread', thread);
+    if (thread === null) return;
+
+    await Thread.updateOne({ code }, { $set: { assistant_id: assistant_id, active: true, stopped: false } });  
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+module.exports = {
+  getThread,
+  getThreadInfo,
+  getAssistantById,
+  createAssistant,
+  replyAssistant,
+  addMsgAssistant,
+  addInsAssistant,
+  switchAssistant
+};

package/lib/services/conversationService.js

@@ -0,0 +1,274 @@
+const { Message } = require('../models/messageModel');
+const { Historial_Clinico_ID } = require('../config/airtableConfig');
+const { getRecordByFilter } = require('./airtableService');
+
+
+const fetchConversationData = async (filter, skip, limit) => {
+  let filterConditions = { is_group: false };
+  
+  switch (filter) {
+  case 'unread':
+    filterConditions = { 
+      is_group: false,
+      from_me: false,
+      $or: [
+        { read: false },
+        { read: { $exists: false } }
+      ]
+    };
+    console.log('Applying unread filter');
+    break;
+
+  case 'no-response':
+    console.log('Applying no-response filter');
+    break;
+
+  case 'recent': {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    filterConditions = { 
+      is_group: false,
+      createdAt: { $gt: yesterday }
+    };
+    console.log('Applying recent filter (last 24 hours)');
+    break;
+  }
+
+  case 'all':
+  default:
+    filterConditions = { is_group: false };
+    console.log('Applying all conversations filter');
+    break;
+  }
+
+  console.log('Executing aggregation pipeline...');
+  const aggregationStartTime = Date.now();
+  
+  let aggregationPipeline = [
+    { $match: filterConditions },
+    { $project: {
+      numero: 1,
+      body: 1,
+      createdAt: 1,
+      timestamp: 1,
+      is_media: 1,
+      media: 1,
+      nombre_whatsapp: 1,
+      from_me: 1
+    }},
+    { $group: {
+      _id: '$numero',
+      latestMessage: { $first: '$$ROOT' },
+      messageCount: { $sum: 1 }
+    }},
+    { $sort: { 'latestMessage.createdAt': -1 } }
+  ];
+
+  if (filter === 'no-response') {
+    aggregationPipeline.splice(-1, 0, { $match: { 'latestMessage.from_me': false } });
+  }
+
+  aggregationPipeline.push(
+    { $skip: skip },
+    { $limit: limit }
+  );
+
+  const conversations = await Message.aggregate(aggregationPipeline);
+
+  const aggregationTime = Date.now() - aggregationStartTime;
+  console.log(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
+
+  // Fetch names from Airtable and WhatsApp
+  const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
+  const formula = 'OR(' +
+    phoneNumbers.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
+    ')';
+  const patientTable = await getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula);
+  const airtableNameMap = patientTable.reduce((map, patient) => {
+    map[patient.whatsapp_id] = patient.name;
+    return map;
+  }, {});
+  console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
+
+  const contactNames = await Message.aggregate([
+    { $match: { is_group: false, from_me: false } },
+    { $sort: { createdAt: -1 } },
+    { $group: {
+      _id: '$numero',
+      name: { $first: '$nombre_whatsapp' }
+    }}
+  ]);
+      
+  const nameMap = contactNames?.reduce((map, contact) => {
+    if (contact && contact._id) {
+      if (!airtableNameMap[contact._id]) {
+        map[contact._id] = contact.name || 'Unknown';
+      }
+    }
+    return map;
+  }, {...airtableNameMap}) || airtableNameMap || {};
+      
+  // Fetch unread counts
+  console.log('Fetching unread counts using Message.aggregate');
+  const unreadCounts = await Message.aggregate([
+    { 
+      $match: { 
+        is_group: false, 
+        from_me: false, 
+        $or: [
+          { read: false },
+          { read: { $exists: false } }
+        ]
+      } 
+    },
+    { $group: {
+      _id: '$numero',
+      unreadCount: { $sum: 1 }
+    }}
+  ]);
+      
+  const unreadMap = unreadCounts?.reduce((map, item) => {
+    if (item && item._id) {
+      map[item._id] = item.unreadCount || 0;
+    }
+    return map;
+  }, {}) || {};
+  console.log('unreadMap', JSON.stringify(unreadMap));
+  console.log('Number of conversations found:', conversations?.length || 0);
+      
+  // Calculate total count for pagination
+  let totalFilterConditions = { is_group: false };
+
+  if (filter === 'unread') {
+    totalFilterConditions = { 
+      is_group: false,
+      from_me: false,
+      $or: [
+        { read: false },
+        { read: { $exists: false } }
+      ]
+    };
+  } else if (filter === 'recent') {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    totalFilterConditions = { 
+      is_group: false,
+      createdAt: { $gt: yesterday }
+    };
+  }
+
+  let totalAggregationPipeline = [
+    { $match: totalFilterConditions },
+    { $group: { _id: '$numero' } },
+    { $count: 'total' }
+  ];
+
+  if (filter === 'no-response') {
+    totalAggregationPipeline = [
+      { $match: { is_group: false } },
+      { $project: {
+        numero: 1,
+        from_me: 1,
+        createdAt: 1
+      }},
+      { $group: {
+        _id: '$numero',
+        latestMessage: { $first: '$$ROOT' }
+      }},
+      { $match: { 'latestMessage.from_me': false } },
+      { $count: 'total' }
+    ];
+  }
+
+  const totalConversations = await Message.aggregate(totalAggregationPipeline, { allowDiskUse: true });
+  const total = totalConversations[0]?.total || 0;
+
+  return { conversations, total, nameMap, unreadMap };
+};
+
+/**
+ * Processes conversations to prepare them for the response
+ */
+const processConversations = async (conversations, nameMap, unreadMap) => {
+  console.log('Processing conversations for response...');
+
+  let processedConversations = [];
+  try {
+    processedConversations = (conversations || []).map((conv, index) => {
+      try {
+        if (!conv || !conv.latestMessage) {
+          console.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
+          return {
+            phoneNumber: conv?._id || 'unknown',
+            name: 'Unknown',
+            lastMessage: '',
+            lastMessageTime: new Date(),
+            messageCount: 0,
+            unreadCount: 0,
+            isLastMessageMedia: false,
+            lastMessageType: null,
+            lastMessageFromMe: false
+          };
+        }
+
+        const isMedia = conv.latestMessage.is_media === true;
+        let mediaType = null;
+
+        if (isMedia && conv?.latestMessage?.media) {
+          if (conv.latestMessage.media.mediaType) {
+            mediaType = conv.latestMessage.media.mediaType;
+          } else if (conv.latestMessage.media.contentType) {
+            const contentType = conv.latestMessage.media.contentType;
+            const contentTypeParts = contentType?.split('/') || ['unknown'];
+            mediaType = contentTypeParts[0] || 'unknown';
+
+            if (mediaType === 'application') {
+              mediaType = 'document';
+            } else if (contentTypeParts[1] === 'webp') {
+              mediaType = 'sticker';
+            }
+          }
+        }
+
+        return {
+          phoneNumber: conv._id,
+          name: nameMap[conv._id] || conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+          lastMessage: conv?.latestMessage?.body || '',
+          lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),
+          messageCount: conv.messageCount || 0,
+          unreadCount: unreadMap[conv._id] || 0,
+          isLastMessageMedia: isMedia || false,
+          lastMessageType: mediaType || null,
+          lastMessageFromMe: conv?.latestMessage?.from_me || false
+        };
+      } catch (convError) {
+        console.error(`Error processing conversation ${index}:`, convError);
+        return {
+          phoneNumber: conv?._id || `error_${index}`,
+          name: 'Error Processing',
+          lastMessage: 'Error processing conversation',
+          lastMessageTime: new Date(),
+          messageCount: 0,
+          unreadCount: 0,
+          isLastMessageMedia: false,
+          lastMessageType: null,
+          lastMessageFromMe: false
+        };
+      }
+    });
+
+    console.log(`Successfully processed ${processedConversations.length} conversations`);
+  
+  } catch (mappingError) {
+    console.error('Error in conversation mapping:', mappingError);
+    // Return empty conversations if mapping fails
+    processedConversations = [];
+  }
+
+  return processedConversations;
+};
+
+module.exports = {
+  fetchConversationData,
+  processConversations
+};

package/lib/services/whatsappService.js

@@ -0,0 +1,23 @@
+let sendMessage;
+let sendScheduledMessage;
+if (process.env.MESSAGING_PROVIDER === 'baileys') {
+  const baileyAdapter = require('../adapters/baileys');
+  console.log('Baileys adapter:', baileyAdapter);
+  console.log('Has sendMessage?', 'sendMessage' in baileyAdapter);
+  sendMessage = baileyAdapter.sendMessage;
+  sendScheduledMessage = baileyAdapter.sendScheduledMessage;
+} else if (process.env.MESSAGING_PROVIDER === 'twilio') {
+  const { sendMessage: twilioSendMessage } = require('../messaging/messageService');
+  const { sendScheduledMessage: twilioSendScheduledMessage } = require('../messaging/scheduledMessageService');
+  const twilioAdapter = require('../adapters/twilio');
+  const twilioClient = twilioAdapter.twilioClient;
+  sendMessage = (messageData) => twilioSendMessage(twilioClient, messageData);
+  sendScheduledMessage = (messageData) => twilioSendScheduledMessage(twilioClient, messageData);
+} else {
+  throw new Error('Unsupported MESSAGING_PROVIDER specified');
+}
+
+module.exports = {
+  sendMessage,
+  sendScheduledMessage
+};

package/lib/utils/index.js

@@ -2,34 +2,10 @@ const AssistantManager = require('./AssistantManager');
 const DefaultLLMProvider = require('./DefaultLLMProvider');
 const MessageParser = require('./MessageParser');
 const logger = require('./logger');
-const { useMongoDBAuthState } = require('./mongoAuthConfig');
-const { 
-  convertTwilioToInternalFormat,
-  downloadMediaFromTwilio,
-  getMediaTypeFromContentType,
-  extractTitle,
-  ensureWhatsAppFormat
-} = require('./twilioHelper');
-const { 
-  delay,
-  formatCode,
-  calculateDelay
-} = require('./whatsappHelper');
 
 module.exports = {
   AssistantManager,
   DefaultLLMProvider,
   MessageParser,
-  logger,
-  useMongoDBAuthState,
-  // Twilio utilities
-  convertTwilioToInternalFormat,
-  downloadMediaFromTwilio,
-  getMediaTypeFromContentType,
-  extractTitle,
-  ensureWhatsAppFormat,
-  // WhatsApp utilities
-  delay,
-  formatCode,
-  calculateDelay
+  logger
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
     "dev": "tsc --watch",
     "test": "jest",
     "lint": "eslint lib/**/*.js",
-    "prepublishOnly": "npm run lint",
+    "prepublishOnly": "npm test && npm run lint",
     "version": "npm run prepublishOnly && git add -A lib",
     "postversion": "git push && git push --tags"
   },
@@ -50,7 +50,9 @@
   "author": "PEOPL Health Tech",
   "license": "MIT",
   "dependencies": {
+    "airtable": "^0.12.2",
     "axios": "^1.5.0",
+    "dotenv": "^16.4.7",
     "moment-timezone": "^0.5.43",
     "mongoose": "^7.5.0",
     "pino": "^8.15.0",

package/lib/utils/twilioHelper.js

@@ -1,75 +0,0 @@
-const axios = require('axios');
-const { v4: uuidv4 } = require('uuid');
-
-function convertTwilioToInternalFormat(twilioMessage) {
-  const from = twilioMessage.From || '';
-  const to = twilioMessage.To || '';
-  const fromMe = to === from;
-    
-  return {
-    key: {
-      id: twilioMessage.MessageSid || uuidv4(),
-      fromMe: fromMe,
-      remoteJid: fromMe ? to : from
-    },
-    pushName: twilioMessage.ProfileName || '',
-    message: {
-      conversation: twilioMessage.Body || ''
-    },
-    messageTimestamp: Math.floor(Date.now() / 1000)
-  };
-}
-
-async function downloadMediaFromTwilio(mediaUrl, credentials) {
-  try {
-    const response = await axios({
-      method: 'GET',
-      url: mediaUrl,
-      responseType: 'arraybuffer',
-      headers: {
-        'Authorization': `Basic ${Buffer.from(
-          `${credentials.accountSid}:${credentials.authToken}`
-        ).toString('base64')}`
-      }
-    });
-        
-    return Buffer.from(response.data);
-  } catch (error) {
-    console.error(`Failed to download media: ${error.message}`);
-    throw error;
-  }
-}
-
-function getMediaTypeFromContentType(contentType) {
-  if (contentType.startsWith('image/')) return 'imageMessage';
-  if (contentType.startsWith('audio/')) return 'audioMessage';
-  if (contentType.startsWith('video/')) return 'videoMessage';
-  if (contentType.startsWith('application/')) return 'documentMessage';
-  return 'unknownMessage';
-}
-
-function extractTitle(message, mediaType) {
-  if (mediaType === 'documentMessage' && message.MediaUrl0) {
-    const urlParts = message.MediaUrl0.split('/');
-    return urlParts[urlParts.length - 1] || null;
-  }
-  return null;
-}
-
-const ensureWhatsAppFormat = (phoneNumber) => {
-  if (!phoneNumber) return null;
-    
-  if (phoneNumber.startsWith('whatsapp:')) {
-    return phoneNumber;
-  }
-    
-  return `whatsapp:${phoneNumber}`;
-};
-
-module.exports = {
-  convertTwilioToInternalFormat,
-  downloadMediaFromTwilio,
-  getMediaTypeFromContentType,
-  extractTitle,
-  ensureWhatsAppFormat
-};

package/lib/utils/whatsappHelper.js

@@ -1,60 +0,0 @@
-const moment = require('moment-timezone');
-
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-function formatCode(codeBase) {
-  const [number, domain] = codeBase.split('@');
-    
-  if (!number || !domain) {
-    throw new Error('Invalid code format: missing number or domain');
-  }
-
-  if (domain !== 's.whatsapp.net') {
-    throw new Error('Invalid domain: must be s.whatsapp.net');
-  }
-
-  let formattedNumber = number;
-
-  if (formattedNumber.endsWith('-2')) {
-    formattedNumber = formattedNumber.slice(0, -2);
-  }
-
-  if (formattedNumber.length === 10) {
-    formattedNumber = '52' + formattedNumber;
-  }
-
-  if (formattedNumber.startsWith('52') && formattedNumber.length === 12) {
-    formattedNumber = formattedNumber.substring(0, 2) + '1' + formattedNumber.substring(2);
-  }
-  return `${formattedNumber}@s.whatsapp.net`;
-}
-
-function calculateDelay(sendTime, timeZone) {
-  if (sendTime !== undefined && timeZone !== undefined) {
-    const sendMoment = moment.tz(sendTime, timeZone);
-
-    if (!sendMoment.isValid()) {
-      return { error: 'Invalid time format' };
-    }
-
-    const now = moment().tz(timeZone);
-    const randomDelay = Math.floor(Math.random() * 15001) + 15000;
-    const delay = sendMoment.diff(now) + randomDelay;
-
-    if (delay <= 0) {
-      return 2500;
-    }
-
-    return delay;
-  } else {
-    return 2500;
-  }
-}
-
-module.exports = {
-  delay,
-  formatCode,
-  calculateDelay
-};