@peopl-health/nexus 1.5.2 → 1.5.4

package/lib/adapters/TwilioProvider.js

@@ -151,30 +151,67 @@ class TwilioProvider extends MessageProvider {
   }
 
   /**
-   * Attempt to check approval status.
-   * Twilio SDK may not expose approval requests directly; return content and null approval by default.
+   * Check template approval status using Twilio Content API helpers
    */
   async checkApprovalStatus(sid) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
     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) {
-        return { content, approvalRequest: null, warning: 'Approval endpoint not provided by Twilio' };
-      }
-      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 content = await this.twilioClient.content.v1.contents(sid).fetch();
+      let processedApprovalRequest = null;
+
+      try {
+        const approvalRequest = await this.twilioClient.content.v1
+          .contents(sid)
+          .approvalFetch()
+          .fetch();
+
+        if (approvalRequest) {
+          processedApprovalRequest = {
+            sid: approvalRequest.sid,
+            status: 'UNKNOWN'
+          };
+
+          if (approvalRequest.whatsapp) {
+            processedApprovalRequest.status = approvalRequest.whatsapp.status?.toUpperCase() || 'UNKNOWN';
+            processedApprovalRequest.category = approvalRequest.whatsapp.category;
+            processedApprovalRequest.name = approvalRequest.whatsapp.name;
+            processedApprovalRequest.rejectionReason = approvalRequest.whatsapp.rejection_reason;
+            processedApprovalRequest.contentType = approvalRequest.whatsapp.content_type;
+          } else {
+            processedApprovalRequest.status = approvalRequest.status || 'PENDING';
+          }
+
+          if (processedApprovalRequest.status === 'approved') {
+            processedApprovalRequest.status = 'APPROVED';
+          } else if (processedApprovalRequest.status === 'rejected') {
+            processedApprovalRequest.status = 'REJECTED';
+          } else if (processedApprovalRequest.status === 'pending') {
+            processedApprovalRequest.status = 'PENDING';
+          }
+
+          if (approvalRequest.dateCreated || approvalRequest.date_created) {
+            processedApprovalRequest.dateCreated = approvalRequest.dateCreated || approvalRequest.date_created;
+          }
+
+          if (approvalRequest.dateUpdated || approvalRequest.date_updated) {
+            processedApprovalRequest.dateUpdated = approvalRequest.dateUpdated || approvalRequest.date_updated;
+          }
+        }
+      } catch (approvalError) {
+        console.warn('Approval request fetch failed:', approvalError?.message || approvalError);
       }
-      const approvalRequest = Array.isArray(approvals) && approvals.length > 0 ? approvals[0] : null;
-      return { content, approvalRequest };
+
+      return {
+        content,
+        approvalRequest: processedApprovalRequest
+      };
     } catch (error) {
-      // If approval endpoint unavailable, return content only
-      return { content, approvalRequest: null, warning: error.message };
+      console.error('Error checking approval status:', error);
+      throw error;
     }
   }
 

package/lib/core/NexusMessaging.js

@@ -1,5 +1,4 @@
 const { airtable, getBase } = require('../config/airtableConfig');
-const { convertTwilioToInternalFormat } = require('../helpers/twilioHelper');
 const { replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
 
@@ -27,7 +26,15 @@ class NexusMessaging {
       onFlow: null
     };
     this.events = new EventEmitter();
-    this.middleware = { any: [], message: [], interactive: [], media: [], command: [], keyword: [], flow: [] };
+    this.middleware = {
+      any: [],
+      message: [],
+      interactive: [],
+      media: [],
+      command: [],
+      keyword: [],
+      flow: []
+    };
   }
 
   /**
@@ -118,7 +125,11 @@ class NexusMessaging {
    * 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); }];
+    const chain = [
+      ...(this.middleware.any || []),
+      ...(this.middleware[type] || []),
+      async (ctx) => await finalHandler(ctx)
+    ];
     let idx = -1;
     const runner = async (i) => {
       if (i <= idx) throw new Error('next() called multiple times');
@@ -316,32 +327,69 @@ class NexusMessaging {
     }
   }
 
-  async handleMessage(messageData) {
-    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);
+  async _handleWithPipeline(type, handlerKey, messageData, fallback) {
+    this.events.emit(`${type}:received`, messageData);
+    const result = await this._runPipeline(type, messageData, async (ctx) => {
+      const handler = this.handlers[handlerKey];
+      if (handler) {
+        return await handler(ctx, this);
       }
-    };
-    const result = await this._runPipeline('message', messageData, final);
-    this.events.emit && this.events.emit('message:handled', messageData);
+      if (fallback) {
+        return await fallback(ctx);
+      }
+    });
+    this.events.emit(`${type}:handled`, messageData);
     return result;
   }
 
+  _extractAssistantInputs(messageData) {
+    if (!messageData || typeof messageData !== 'object') {
+      return { from: null, message: null };
+    }
+
+    const from = [
+      messageData.from,
+      messageData.sender,
+      messageData.numero,
+      messageData.code,
+      messageData.From,
+      messageData.key?.remoteJid,
+      messageData.raw?.from,
+      messageData.raw?.From,
+      messageData.raw?.key?.remoteJid
+    ].find((value) => typeof value === 'string' && value.trim().length > 0) || null;
+
+    const message = [
+      typeof messageData.message === 'string' ? messageData.message : null,
+      typeof messageData.message?.conversation === 'string' ? messageData.message.conversation : null,
+      typeof messageData.Body === 'string' ? messageData.Body : null,
+      typeof messageData.raw?.message?.conversation === 'string' ? messageData.raw.message.conversation : null,
+      typeof messageData.raw?.Body === 'string' ? messageData.raw.Body : null
+    ].find((value) => typeof value === 'string' && value.trim().length > 0) || null;
+
+    return { from, message };
+  }
+
+  async handleMessage(messageData) {
+    return await this._handleWithPipeline('message', 'onMessage', messageData, async (ctx) => {
+      return await this.handleMessageWithAssistant(ctx);
+    });
+  }
+
   async handleMessageWithAssistant(messageData) {
     try {
-      console.log('MESSAGE DATA', messageData);
+      const { from, message } = this._extractAssistantInputs(messageData);
 
-      const response = await replyAssistant(
-        messageData.from, 
-        messageData.message
-      );
+      if (!from || !message) {
+        console.warn('Unable to resolve assistant inputs from message, skipping automatic reply.');
+        return;
+      }
+
+      const response = await replyAssistant(from, message);
 
       if (response) {
         await this.sendMessage({
-          to: messageData.from,
+          to: from,
           message: response
         });
       }
@@ -354,63 +402,23 @@ class NexusMessaging {
     if (this.messageStorage) {
       await this.messageStorage.saveInteractive(messageData);
     }
-    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;
+    return await this._handleWithPipeline('interactive', 'onInteractive', messageData);
   }
 
   async handleMedia(messageData) {
-    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;
+    return await this._handleWithPipeline('media', 'onMedia', messageData);
   }
 
   async handleCommand(messageData) {
-    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;
+    return await this._handleWithPipeline('command', 'onCommand', messageData);
   }
 
   async handleKeyword(messageData) {
-    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;
+    return await this._handleWithPipeline('keyword', 'onKeyword', messageData);
   }
 
   async handleFlow(messageData) {
-    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;
+    return await this._handleWithPipeline('flow', 'onFlow', messageData);
   }
 
   /**

package/lib/index.js

@@ -67,10 +67,11 @@ class Nexus {
 
     // Auto-configure template controllers with active provider when Twilio is used
     try {
-      const activeProvider = typeof this.messaging.getProvider === 'function' 
-        ? this.messaging.getProvider() 
+      const activeProvider = typeof this.messaging.getProvider === 'function'
+        ? this.messaging.getProvider()
         : null;
-      if (activeProvider && activeProvider.constructor && activeProvider.constructor.name === 'TwilioProvider') {
+
+      if (activeProvider instanceof TwilioProvider) {
         if (typeof templateController.configureNexusProvider === 'function') {
           templateController.configureNexusProvider(activeProvider);
         }
@@ -129,28 +130,24 @@ class Nexus {
     if (llm === 'openai') {
       this.llmProvider = new DefaultLLMProvider(llmConfig);
       try {
-        if (this.llmProvider && typeof this.llmProvider.getClient === 'function') {
+        if (typeof this.llmProvider.getClient === 'function') {
           llmConfigModule.openaiClient = this.llmProvider.getClient();
         }
       } catch (err) {
         console.warn('[Nexus] Failed to expose OpenAI client:', err?.message || err);
       }
+    }
 
     // Convenience: handle common top-level config for mongo, media bucket, airtable
     try {
-      // Mongo URI passthrough for storage=mongo
-      if (options.mongoUri && storage === 'mongo') {
-        if (typeof storageConfig === 'object') {
-          storageConfig.mongoUri = storageConfig.mongoUri || options.mongoUri;
-        }
+      if (options.mongoUri && storage === 'mongo' && typeof storageConfig === 'object') {
+        storageConfig.mongoUri = storageConfig.mongoUri || options.mongoUri;
       }
 
-      // Media bucket (overrides storage setting)
       if (options.media && options.media.bucketName) {
         runtimeConfig.set('AWS_S3_BUCKET_NAME', options.media.bucketName);
       }
 
-      // Airtable base default (accepts alias like 'calendar' or an ID)
       if (options.airtable && options.airtable.base) {
         runtimeConfig.set('AIRTABLE_BASE_ID', options.airtable.base);
       }
@@ -161,13 +158,11 @@ class Nexus {
       console.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
     }
 
-    }
-
 
     // Configure Assistants (registry + overrides)
     const assistantsConfig = assistantsOpt || assistantOpt;
     try {
-      if (this.llmProvider && typeof configureAssistantsLLM === 'function') {
+      if (this.llmProvider && typeof configureAssistantsLLM === 'function' && typeof this.llmProvider.getClient === 'function') {
         // Provide the raw OpenAI client to the assistant service
         configureAssistantsLLM(this.llmProvider.getClient());
       }

package/lib/services/conversationService.js

@@ -56,6 +56,7 @@ const fetchConversationData = async (filter, skip, limit) => {
       nombre_whatsapp: 1,
       from_me: 1
     }},
+    { $sort: { createdAt: 1, timestamp: 1 } },
     { $group: {
       _id: '$numero',
       latestMessage: { $last: '$$ROOT' },
@@ -169,8 +170,10 @@ const fetchConversationData = async (filter, skip, limit) => {
       { $project: {
         numero: 1,
         from_me: 1,
-        createdAt: 1
+        createdAt: 1,
+        timestamp: 1
       }},
+      { $sort: { createdAt: -1, timestamp: -1 } },
       { $group: {
         _id: '$numero',
         latestMessage: { $first: '$$ROOT' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"
@@ -67,7 +67,7 @@
     "baileys": "^6.4.0",
     "express": "4.21.2",
     "openai": "^4.0.0",
-    "twilio": "^5.6.0"
+    "twilio": "5.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.5.0",