@peopl-health/nexus 1.5.5 → 1.5.7

package/lib/config/llmConfig.js

@@ -1,3 +1,28 @@
+const runtimeConfig = require('./runtimeConfig');
+
+let anthropicClient = null;
+
+const resolveAnthropicClient = () => {
+  if (anthropicClient) return anthropicClient;
+
+  const apiKey = runtimeConfig.get('ANTHROPIC_API_KEY') || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return null;
+
+  try {
+    const { Anthropic } = require('@anthropic-ai/sdk');
+    anthropicClient = new Anthropic({ apiKey });
+    console.log('[llmConfig] Anthropic client initialised');
+  } catch (error) {
+    console.warn('[llmConfig] Failed to initialise Anthropic client. Install @anthropic-ai/sdk if you plan to use vision features.', error?.message || error);
+    anthropicClient = null;
+  }
+
+  return anthropicClient;
+};
+
 module.exports = {
-  openaiClient: null
+  openaiClient: null,
+  get anthropicClient() {
+    return resolveAnthropicClient();
+  }
 };

package/lib/core/NexusMessaging.js

@@ -1,6 +1,7 @@
 const { airtable, getBase } = require('../config/airtableConfig');
 const { replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
+const runtimeConfig = require('../config/runtimeConfig');
 
 const mongoose = require('mongoose');
 const OpenAI = require('openai');
@@ -374,7 +375,12 @@ class NexusMessaging {
       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
+      typeof messageData.raw?.Body === 'string' ? messageData.raw.Body : null,
+      typeof messageData.caption === 'string' ? messageData.caption : null,
+      typeof messageData.media?.caption === 'string' ? messageData.media.caption : null,
+      Array.isArray(messageData.media) && typeof messageData.media[0]?.caption === 'string'
+        ? messageData.media[0].caption
+        : null
     ].find((value) => typeof value === 'string' && value.trim().length > 0) || null;
 
     return { from, message };
@@ -416,7 +422,109 @@ class NexusMessaging {
   }
 
   async handleMedia(messageData) {
-    return await this._handleWithPipeline('media', 'onMedia', messageData);
+    await this._ensureMediaPersistence(messageData);
+
+    return await this._handleWithPipeline('media', 'onMedia', messageData, async (ctx) => {
+      return await this.handleMediaWithAssistant(ctx);
+    });
+  }
+
+  async handleMediaWithAssistant(messageData) {
+    try {
+      const { from, message } = this._extractAssistantInputs(messageData);
+
+      if (!from) {
+        console.warn('Unable to resolve sender for media message, skipping automatic reply.');
+        return;
+      }
+
+      const mediaDescriptor = (() => {
+        const media = Array.isArray(messageData.media) ? messageData.media[0] : messageData.media;
+        if (!media) return null;
+        if (typeof media.mediaType === 'string') return media.mediaType;
+        if (typeof media.type === 'string') return media.type;
+        if (typeof media.contentType === 'string') return media.contentType;
+        return null;
+      })();
+
+      const fallbackMessage = message && message.trim().length > 0
+        ? message
+        : `Media received (${mediaDescriptor || 'attachment'})`;
+
+      const response = await replyAssistant(from, fallbackMessage);
+
+      if (response) {
+        await this.sendMessage({
+          to: from,
+          message: response
+        });
+      }
+    } catch (error) {
+      console.error('Error in handleMediaWithAssistant:', error);
+    }
+  }
+
+  async _ensureMediaPersistence(messageData) {
+    try {
+      const raw = messageData?.raw;
+      if (!raw || raw.__nexusMediaProcessed) return;
+
+      const numMedia = parseInt(raw.NumMedia || '0', 10);
+      if (!numMedia || numMedia <= 0 || !raw.MediaUrl0) return;
+
+      const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME') || process.env.AWS_S3_BUCKET_NAME;
+      if (!bucketName) {
+        console.warn('[NexusMessaging] AWS_S3_BUCKET_NAME not configured. Skipping media persistence.');
+        return;
+      }
+
+      const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor');
+      const { logger } = require('../utils/logger');
+      const mediaItems = await processTwilioMediaMessage(raw, logger, bucketName);
+
+      if (!mediaItems || mediaItems.length === 0) {
+        console.warn('[NexusMessaging] Media processing returned no items for incoming message.');
+        return;
+      }
+
+      raw.__nexusMediaProcessed = true;
+
+      const [primary, ...rest] = mediaItems;
+      const mediaPayload = rest.length > 0
+        ? { ...primary, metadata: { ...(primary.metadata || {}), attachments: rest } }
+        : primary;
+
+      messageData.media = messageData.media || mediaPayload;
+      messageData.fileUrl = messageData.fileUrl || mediaPayload.metadata?.presignedUrl || null;
+      messageData.fileType = messageData.fileType || mediaPayload.mediaType;
+      messageData.caption = messageData.caption || primary.caption;
+      if (!messageData.message && messageData.caption) {
+        messageData.message = messageData.caption;
+      }
+      messageData.isMedia = true;
+
+      if (!this.messageStorage) {
+        const { convertTwilioToInternalFormat } = require('../helpers/twilioHelper');
+        const { getMessageValues, insertMessage } = require('../models/messageModel');
+
+        const messageObj = convertTwilioToInternalFormat(raw);
+        const values = getMessageValues(
+          messageObj,
+          messageData.message || messageData.caption || '',
+          null,
+          true
+        );
+        values.media = mediaPayload;
+
+        await insertMessage(values);
+        console.log('[NexusMessaging] Media message stored via legacy inserter', {
+          messageId: values.message_id,
+          numero: values.numero
+        });
+      }
+    } catch (error) {
+      console.error('[NexusMessaging] Failed to ensure media persistence:', error);
+    }
   }
 
   async handleCommand(messageData) {

package/lib/helpers/assistantHelper.js

@@ -211,18 +211,23 @@ async function processMessage(code, reply, thread) {
           continue;
         }
         if (fileName.includes('image') || fileName.includes('document') || fileName.includes('application')) {
-          const imageAnalysis = await analyzeImage(fileName);
+          let imageAnalysis = null;
+          try {
+            imageAnalysis = await analyzeImage(fileName);
+          } catch (error) {
+            console.warn('[assistantHelper] analyzeImage failed:', error?.message || error);
+          }
           console.log(imageAnalysis);
           const invalidAnalysis = ['NOT_MEDICAL', 'QUALITY_INSUFFICIENT'];
-          if (imageAnalysis.medical_relevance) {
+          if (imageAnalysis?.medical_relevance) {
             url = await generatePresignedUrl(reply.media.bucketName, reply.media.key);            
           }
-          if (imageAnalysis.has_table) {
+          if (imageAnalysis?.has_table && imageAnalysis.table_data) {
             messagesChat.push({
               type: 'text',
               text: imageAnalysis.table_data,
             });
-          } else if (!invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
+          } else if (imageAnalysis?.medical_analysis && !invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
             messagesChat.push({
               type: 'text',
               text: imageAnalysis.medical_analysis,

package/lib/helpers/llmsHelper.js

@@ -1,10 +1,21 @@
-const { anthropicClient } = require('../config/llmConfig.js');
+const llmConfig = require('../config/llmConfig.js');
 const fs = require('fs');
 const mime = require('mime-types');
 
 
 async function analyzeImage(imagePath) {
   try {
+    const anthropicClient = llmConfig.anthropicClient;
+    if (!anthropicClient || !anthropicClient.messages) {
+      console.warn('[llmsHelper] Anthropics client not configured; skipping image analysis');
+      return {
+        medical_analysis: 'QUALITY_INSUFFICIENT',
+        medical_relevance: false,
+        has_table: false,
+        table_data: null
+      };
+    }
+
     // Skip WBMP images and stickers
     if (imagePath.toLowerCase().includes('.wbmp') || imagePath.toLowerCase().includes('sticker')) {
       console.log('Skipping WBMP image or sticker analysis:', imagePath);

package/lib/storage/MongoStorage.js

@@ -120,6 +120,8 @@ class MongoStorage {
         ? { ...primary, metadata: { ...(primary.metadata || {}), attachments: rest } }
         : primary;
 
+      rawMessage.__nexusMediaProcessed = true;
+
       console.log('[MongoStorage] Media processed successfully', {
         primaryType: mediaPayload.mediaType,
         mediaCount: mediaItems.length,

package/package.json

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