@peopl-health/nexus 1.5.5 → 1.5.6

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/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.6",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"