@peopl-health/nexus 1.1.8 → 1.3.0

package/lib/adapters/BaileysProvider.js

@@ -14,7 +14,10 @@ class BaileysProvider extends MessageProvider {
 
   async initialize() {
     try {
-      const { default: makeWASocket, useMultiFileAuthState } = require('baileys');
+      const baileys = require('baileys');
+      // Support both CJS and ESM shapes
+      const makeWASocket = baileys.default || baileys.makeWASocket || baileys;
+      const useMultiFileAuthState = baileys.useMultiFileAuthState || baileys.useMultiFileAuthState;
       const { useMongoDBAuthState } = require('../config/mongoAuthConfig');
       const pino = require('pino');
       
@@ -175,6 +178,27 @@ class BaileysProvider extends MessageProvider {
     }
     this.isConnected = false;
   }
+
+  // Content/Template operations are not supported for Baileys
+  async listTemplates() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async getTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async checkApprovalStatus() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async submitForApproval() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async deleteTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+  async createTemplate() {
+    throw new Error('Template operations are only supported with Twilio provider');
+  }
+
 }
 
 module.exports = { BaileysProvider };

package/lib/adapters/TwilioProvider.js

@@ -1,4 +1,5 @@
 const { MessageProvider } = require('../core/MessageProvider');
+const axios = require('axios');
 
 /**
  * Twilio WhatsApp messaging provider
@@ -132,6 +133,112 @@ class TwilioProvider extends MessageProvider {
       throw new Error(`Failed to list templates: ${error.message}`);
     }
   }
+
+  /**
+   * Fetch a specific template/content by SID
+   */
+  async getTemplate(sid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!sid) throw new Error('Content SID is required');
+    try {
+      const content = await this.twilioClient.content.v1.contents(sid).fetch();
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get template: ${error.message}`);
+    }
+  }
+
+  /**
+   * Attempt to check approval status.
+   * Twilio SDK may not expose approval requests directly; return content and null approval by default.
+   */
+  async checkApprovalStatus(sid) {
+    if (!sid) throw new Error('Content SID is required');
+    const content = await this.getTemplate(sid);
+    try {
+      const links = (content && content.links) || {};
+      let approvalsUrl = links.approvals || links.approvalRequests || links.approval_requests;
+      if (!approvalsUrl) {
+        approvalsUrl = 'https://content.twilio.com/v1/Content/' + sid + '/ApprovalRequests';
+      }
+      const resp = await axios.get(approvalsUrl, { auth: { username: this.accountSid, password: this.authToken } });
+      const data = resp && resp.data ? resp.data : null;
+      let approvals = [];
+      if (data) {
+        approvals = data.approval_requests || data.approvalRequests || data.results || data.data || (Array.isArray(data) ? data : []);
+        if (!Array.isArray(approvals) && data.approvalRequest) approvals = [data.approvalRequest];
+      }
+      const approvalRequest = Array.isArray(approvals) && approvals.length > 0 ? approvals[0] : null;
+      return { content, approvalRequest };
+    } catch (error) {
+      // If approval endpoint unavailable, return content only
+      return { content, approvalRequest: null, warning: error.message };
+    }
+  }
+
+  /**
+   * Submit template for approval (best-effort placeholder)
+   */
+  async submitForApproval(contentSid, name, category) {
+    if (!contentSid) throw new Error('Content SID is required');
+    const content = await this.getTemplate(contentSid);
+    try {
+      const links = (content && content.links) || {};
+      let approvalsUrl = links.approvals || links.approvalRequests || links.approval_requests;
+      if (!approvalsUrl) {
+        approvalsUrl = 'https://content.twilio.com/v1/Content/' + contentSid + '/ApprovalRequests';
+      }
+      const payload = {
+        name,
+        category,
+        friendly_name: name,
+        categories: category ? [category] : undefined,
+        channel: 'whatsapp'
+      };
+      const resp = await axios.post(approvalsUrl, payload, { auth: { username: this.accountSid, password: this.authToken } });
+      return { success: true, contentSid, approvalRequest: resp.data || null };
+    } catch (error) {
+      throw new Error(`Failed to submit for approval: ${error.message}`);
+    }
+  }
+
+  /**
+   * Delete a template/content by SID
+   */
+  async deleteTemplate(sid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!sid) throw new Error('Content SID is required');
+    try {
+      await this.twilioClient.content.v1.contents(sid).remove();
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Failed to delete template: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a template/content using Twilio Content API
+   * @param {Object} templateData - Must follow Twilio Content API schema
+   */
+  async createTemplate(templateData) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+    if (!templateData || typeof templateData !== 'object') {
+      throw new Error('templateData must be an object');
+    }
+    try {
+      const created = await this.twilioClient.content.v1.contents.create(templateData);
+      return created;
+    } catch (error) {
+      throw new Error(`Failed to create template: ${error.message}`);
+    }
+  }
+
 }
 
 module.exports = { TwilioProvider };

package/lib/adapters/registry.js

@@ -0,0 +1,29 @@
+const { TwilioProvider } = require('./TwilioProvider');
+const { BaileysProvider } = require('./BaileysProvider');
+
+const _providers = new Map();
+
+function registerProvider(name, ProviderClass) {
+  if (!name || !ProviderClass) throw new Error('registerProvider requires name and ProviderClass');
+  _providers.set(String(name).toLowerCase(), ProviderClass);
+}
+
+function getProvider(name) {
+  return _providers.get(String(name || '').toLowerCase());
+}
+
+function createProvider(name, config) {
+  const ProviderClass = getProvider(name);
+  if (!ProviderClass) throw new Error(`Unsupported provider: ${name}`);
+  return new ProviderClass(config || {});
+}
+
+// Register built-ins
+registerProvider('twilio', TwilioProvider);
+registerProvider('baileys', BaileysProvider);
+
+module.exports = {
+  registerProvider,
+  getProvider,
+  createProvider
+};

package/lib/config/configLoader.js

@@ -0,0 +1,38 @@
+const path = require('path');
+
+const defaults = {
+  provider: { name: 'twilio', config: {} },
+  storage: null,
+  features: { airtable: true, s3: true },
+  assistants: { registry: {}, select: {}, getAssistantById: null },
+  handlers: {},
+  interactive: {}
+};
+
+function merge(a, b) {
+  if (!b) return { ...a };
+  const out = { ...a };
+  for (const k of Object.keys(b)) {
+    if (b[k] && typeof b[k] === 'object' && !Array.isArray(b[k])) {
+      out[k] = merge(a[k] || {}, b[k]);
+    } else {
+      out[k] = b[k];
+    }
+  }
+  return out;
+}
+
+function loadNexusConfig(userConfig) {
+  if (userConfig && typeof userConfig === 'object') {
+    return merge(defaults, userConfig);
+  }
+  try {
+    const localPath = path.resolve(process.cwd(), 'nexus.config.js');
+    const fileConfig = require(localPath);
+    return merge(defaults, fileConfig || {});
+  } catch {
+    return { ...defaults };
+  }
+}
+
+module.exports = { loadNexusConfig, defaults };

package/lib/controllers/assistantController.js

@@ -34,7 +34,7 @@ const addInsAssistantController = async (req, res) => {
 };
 
 const addMsgAssistantController = async (req, res) => {
-  const { code, messages, reply } = req.body;
+  const { code, messages, reply = false } = req.body;
 
   try {
     const ans = await addMsgAssistant(code, messages, reply);
@@ -47,7 +47,7 @@ const addMsgAssistantController = async (req, res) => {
 };
 
 const createAssistantController = async (req, res) => {
-  const { assistant_id, codes, messages=[], force=false } = req.body;
+  const { assistant_id, codes, instrucciones=[], messages=[], force=false } = req.body;
   if (!Array.isArray(codes) || codes.length === 0) {
     return res.status(400).send({ error: 'codes must be a non-empty array' });
   }
@@ -62,7 +62,7 @@ const createAssistantController = async (req, res) => {
         if (!force) continue;
       }
 
-      await createAssistant(code, assistant_id, messages, thread);
+      await createAssistant(code, assistant_id, [...instrucciones, ...messages], thread);
       console.log('messages', messages);
       for (const message of messages) {
         console.log('message', message);

package/lib/controllers/messageController.js

@@ -1,3 +1,5 @@
+const { Message } = require('../models/messageModel.js');
+
 // Import from Nexus core
 const { sendMessage } = require('../core/NexusMessaging');
 
@@ -223,8 +225,36 @@ const sendBulkMessageAirtableController = async (req, res) => {
   }
 };
 
+const getLastInteractionController = async (req, res) => {
+  const { code } = req.body;
+
+  try {
+    const lastMessage = await Message.findOne({
+      $or: [
+        { numero: code },
+        { group_id: code }
+      ]
+    }).sort({ createdAt: -1 }).exec();
+
+    if (!lastMessage) {
+      return res.status(404).send({ message: 'No messages found for the provided code.' });
+    }
+      
+    const createdAt = new Date(lastMessage.createdAt);
+    const now = new Date();
+    const timeDiffMs = now - createdAt;
+    const minutes = Math.floor(timeDiffMs / (1000 * 60));
+
+    return res.status(200).send({ message: 'Last interaction retrieved successfully.', lastMessage, minutes });
+  } catch (error) {
+    console.error(error);
+    return res.status(500).send({ message: 'Failed to retrieve the last interaction.', error });
+  }
+};
+
 module.exports = {
   sendMessageController,
   sendBulkMessageController,
-  sendBulkMessageAirtableController
+  sendBulkMessageAirtableController,
+  getLastInteractionController
 };

package/lib/core/NexusMessaging.js

@@ -1,8 +1,11 @@
-const { TwilioProvider } = require('../adapters/TwilioProvider');
-const { BaileysProvider } = require('../adapters/BaileysProvider');
-const mongoose = require('mongoose');
 const { airtable, getBase } = require('../config/airtableConfig');
+const { convertTwilioToInternalFormat } = require('../helpers/twilioHelper');
+const { replyAssistant } = require('../services/assistantService');
+const { createProvider } = require('../adapters/registry');
+
+const mongoose = require('mongoose');
 const OpenAI = require('openai');
+const EventEmitter = require('events');
 
 /**
  * Core messaging class that manages providers and message handling
@@ -23,6 +26,8 @@ class NexusMessaging {
       onKeyword: null,
       onFlow: null
     };
+    this.events = new EventEmitter();
+    this.middleware = { any: [], message: [], interactive: [], media: [], command: [], keyword: [], flow: [] };
   }
 
   /**
@@ -79,6 +84,54 @@ class NexusMessaging {
     return this.llmProvider;
   }
 
+  /**
+   * Get the underlying messaging provider instance
+   */
+  getProvider() {
+    return this.provider;
+  }
+
+  /**
+   * Access the internal event bus (EventEmitter)
+   */
+  getEventBus() {
+    return this.events;
+  }
+
+  /**
+   * Register middleware. Usage: use(type, fn) or use(fn) for global.
+   * Middleware signature: async (messageData, nexus, next) => {}
+   */
+  use(typeOrFn, maybeFn) {
+    if (typeof typeOrFn === 'function') {
+      this.middleware.any.push(typeOrFn);
+      return this;
+    }
+    const type = String(typeOrFn || '').toLowerCase();
+    const fn = maybeFn;
+    if (!this.middleware[type]) this.middleware[type] = [];
+    this.middleware[type].push(fn);
+    return this;
+  }
+
+  /**
+   * Internal helper to run middleware pipeline and the final handler
+   */
+  async _runPipeline(type, messageData, finalHandler) {
+    const chain = [...(this.middleware.any || []), ...(this.middleware[type] || []), async (ctx) => { return finalHandler(ctx); }];
+    let idx = -1;
+    const runner = async (i) => {
+      if (i <= idx) throw new Error('next() called multiple times');
+      idx = i;
+      const fn = chain[i];
+      if (!fn) return;
+      return await fn(messageData, this, () => runner(i+1));
+    };
+    return await runner(0);
+  }
+
+
+
   /**
    * Initialize Nexus with all services
    * @param {Object} options - Configuration options
@@ -122,17 +175,7 @@ class NexusMessaging {
    * @param {Object} providerConfig - Provider-specific configuration
    */
   async initializeProvider(providerType, providerConfig) {
-    switch (providerType.toLowerCase()) {
-    case 'twilio':
-      this.provider = new TwilioProvider(providerConfig);
-      break;
-    case 'baileys':
-      this.provider = new BaileysProvider(providerConfig);
-      break;
-    default:
-      throw new Error(`Unsupported provider: ${providerType}`);
-    }
-
+    this.provider = createProvider(providerType, providerConfig);
     await this.provider.initialize();
   }
 
@@ -209,12 +252,18 @@ class NexusMessaging {
       throw new Error('No provider initialized');
     }
 
-    const result = await this.provider.sendMessage(messageData);
+    // Backward compatibility: accept `code` as destination
+    const normalized = { ...messageData };
+    if (!normalized.to && normalized.code) {
+      normalized.to = normalized.code;
+    }
+
+    const result = await this.provider.sendMessage(normalized);
     
     // Store message if storage is configured
     if (this.messageStorage) {
       await this.messageStorage.saveMessage({
-        ...messageData,
+        ...normalized,
         messageId: result.messageId,
         provider: result.provider,
         timestamp: new Date(),
@@ -268,44 +317,111 @@ class NexusMessaging {
   }
 
   async handleMessage(messageData) {
-    if (this.handlers.onMessage) {
-      return await this.handlers.onMessage(messageData, this);
+    this.events.emit && this.events.emit('message:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onMessage) {
+        return await this.handlers.onMessage(ctx, this);
+      } else {
+        return await this.handleMessageWithAssistant(ctx);
+      }
+    };
+    const result = await this._runPipeline('message', messageData, final);
+    this.events.emit && this.events.emit('message:handled', messageData);
+    return result;
+  }
+
+  async handleMessageWithAssistant(messageData) {
+    try {
+      // Convert Twilio format to internal format if needed
+      const internalMessage = this.provider.constructor.name === 'TwilioProvider' 
+        ? convertTwilioToInternalFormat(messageData)
+        : messageData;
+
+      // Extract standardized data
+      const extractedData = {
+        from: internalMessage.key?.remoteJid || '',
+        message: internalMessage.message?.conversation || '',
+        messageId: internalMessage.key?.id || '',
+        fromMe: internalMessage.key?.fromMe || false
+      };
+
+      const response = await replyAssistant(
+        extractedData.from, 
+        extractedData.message
+      );
+
+      if (response) {
+        await this.sendMessage({
+          to: extractedData.from,
+          message: response
+        });
+      }
+    } catch (error) {
+      console.error('Error in handleMessageWithAssistant:', error);
     }
   }
 
   async handleInteractive(messageData) {
-    // Store interactive message
     if (this.messageStorage) {
       await this.messageStorage.saveInteractive(messageData);
     }
-
-    if (this.handlers.onInteractive) {
-      return await this.handlers.onInteractive(messageData, this);
-    }
+    this.events.emit && this.events.emit('interactive:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onInteractive) {
+        return await this.handlers.onInteractive(ctx, this);
+      }
+    };
+    const result = await this._runPipeline('interactive', messageData, final);
+    this.events.emit && this.events.emit('interactive:handled', messageData);
+    return result;
   }
 
   async handleMedia(messageData) {
-    if (this.handlers.onMedia) {
-      return await this.handlers.onMedia(messageData, this);
-    }
+    this.events.emit && this.events.emit('media:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onMedia) {
+        return await this.handlers.onMedia(ctx, this);
+      }
+    };
+    const result = await this._runPipeline('media', messageData, final);
+    this.events.emit && this.events.emit('media:handled', messageData);
+    return result;
   }
 
   async handleCommand(messageData) {
-    if (this.handlers.onCommand) {
-      return await this.handlers.onCommand(messageData, this);
-    }
+    this.events.emit && this.events.emit('command:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onCommand) {
+        return await this.handlers.onCommand(ctx, this);
+      }
+    };
+    const result = await this._runPipeline('command', messageData, final);
+    this.events.emit && this.events.emit('command:handled', messageData);
+    return result;
   }
 
   async handleKeyword(messageData) {
-    if (this.handlers.onKeyword) {
-      return await this.handlers.onKeyword(messageData, this);
-    }
+    this.events.emit && this.events.emit('keyword:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onKeyword) {
+        return await this.handlers.onKeyword(ctx, this);
+      }
+    };
+    const result = await this._runPipeline('keyword', messageData, final);
+    this.events.emit && this.events.emit('keyword:handled', messageData);
+    return result;
   }
 
   async handleFlow(messageData) {
-    if (this.handlers.onFlow) {
-      return await this.handlers.onFlow(messageData, this);
-    }
+    this.events.emit && this.events.emit('flow:received', messageData);
+    const final = async (ctx) => {
+      if (this.handlers.onFlow) {
+        return await this.handlers.onFlow(ctx, this);
+      }
+    };
+    const result = await this._runPipeline('flow', messageData, final);
+    this.events.emit && this.events.emit('flow:handled', messageData);
+    return result;
   }
 
   /**

package/lib/helpers/assistantHelper.js

@@ -1,7 +1,7 @@
 const { downloadFileFromS3, generatePresignedUrl } = require('../config/awsConfig.js');
 const { openaiClient } = require('../config/llmConfig.js');
 
-const { LegacyMessage } = require('../models/messageModel.js');
+const { Message } = require('../models/messageModel.js');
 
 const { convertPdfToImages } = require('./filesHelper.js');
 const { analyzeImage } = require('../helpers/llmsHelper.js');
@@ -78,7 +78,7 @@ async function getLastMessages(code) {
       query.is_group = false;
     }
 
-    const lastMessages = await LegacyMessage.find(query).sort({ timestamp: -1 });
+    const lastMessages = await Message.find(query).sort({ timestamp: -1 });
     console.log('[getLastMessages] lastMessages', lastMessages.map(msg => msg.body).join('\n\n'));
 
     if (lastMessages.length === 0) return [];
@@ -86,7 +86,7 @@ async function getLastMessages(code) {
     let patientReply = [];
     for (const message of lastMessages) {
       patientReply.push(message);
-      await LegacyMessage.updateOne(
+      await Message.updateOne(
         { message_id: message.message_id, timestamp: message.timestamp },
         { $set: { processed: true } }
       );
@@ -101,7 +101,7 @@ async function getLastMessages(code) {
 
 async function getLastNMessages(code, n) {
   try {
-    const lastMessages = await LegacyMessage.find({ numero: code })
+    const lastMessages = await Message.find({ numero: code })
       .sort({ timestamp: -1 })
       .limit(n);
 
@@ -149,7 +149,7 @@ function formatMessage(reply) {
 }
 
 async function downloadMediaAndCreateFile(code, reply) {
-  const resultMedia = await LegacyMessage.findOne({
+  const resultMedia = await Message.findOne({
     message_id: reply.message_id,
     timestamp: reply.timestamp,
     media: { $ne: null }
@@ -259,7 +259,7 @@ async function processMessage(code, reply, thread) {
 
     console.log('Formatted message:', formattedMessage);
 
-    await LegacyMessage.updateOne(
+    await Message.updateOne(
       { message_id: reply.message_id, timestamp: reply.timestamp },
       { $set: { assistant_id: thread.assistant_id, thread_id: thread.thread_id } }
     );

package/lib/helpers/baileysHelper.js

@@ -1,4 +1,4 @@
-const { LegacyMessage, insertMessage, getMessageValues } = require('../models/messageModel.js');
+const { Message, insertMessage, getMessageValues } = require('../models/messageModel.js');
 const { uploadMediaToS3 } = require('./mediaHelper.js');
 const { downloadMediaMessage } = require('baileys');
 
@@ -103,7 +103,7 @@ function extractContentTypeAndReply(message, messageType) {
 async function isRecentMessage(chatId) {
   const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
 
-  const recentMessage = await LegacyMessage.find({
+  const recentMessage = await Message.find({
     $or: [{ group_id: chatId }, { numero: chatId }],
     timestamp: { $gte: fiveMinutesAgo.toISOString() }
   }).sort({ timestamp: -1 }).limit(1);
@@ -112,7 +112,7 @@ async function isRecentMessage(chatId) {
 }
 
 async function getLastMessages(chatId, n) {
-  const messages = await LegacyMessage.find({ group_id: chatId })
+  const messages = await Message.find({ group_id: chatId })
     .sort({ timestamp: -1 })
     .limit(n)
     .select('timestamp numero nombre_whatsapp body');

package/lib/helpers/twilioHelper.js

@@ -1,4 +1,4 @@
-const { LegacyMessage } = require('../models/messageModel');
+const { Message } = require('../models/messageModel');
 
 const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
@@ -68,7 +68,7 @@ function extractTitle(message, mediaType) {
 async function isRecentMessage(chatId) {
   const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
 
-  const recentMessage = await LegacyMessage.find({
+  const recentMessage = await Message.find({
     $or: [{ group_id: chatId }, { numero: chatId }],
     timestamp: { $gte: fiveMinutesAgo.toISOString() }
   }).sort({ timestamp: -1 }).limit(1);
@@ -78,7 +78,7 @@ async function isRecentMessage(chatId) {
 
 
 async function getLastMessages(chatId, n) {
-  const messages = await LegacyMessage.find({ numero: chatId })
+  const messages = await Message.find({ numero: chatId })
     .sort({ timestamp: -1 })
     .limit(n)
     .select('timestamp numero nombre_whatsapp body');

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-declare module '@peopl/nexus' {
+declare module '@peopl-health/nexus' {
   import { EventEmitter } from 'events';
   import mongoose from 'mongoose';