@peopl-health/nexus 2.4.6 → 2.4.8

package/lib/helpers/processHelper.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const { generatePresignedUrl } = require('../config/awsConfig.js');
 const { analyzeImage } = require('./llmsHelper.js');
 const { cleanupFiles, downloadMediaAndCreateFile } = require('./filesHelper.js');
-const { formatMessage, addMessageToThread, updateMessageRecord } = require('./messageHelper.js');
+const { formatMessage } = require('./messageHelper.js');
 const { sanitizeLogMetadata } = require('../utils/sanitizer.js');
 
 /**
@@ -61,13 +61,18 @@ const processImageFile = async (fileName, reply) => {
   let url = null;
   const messagesChat = [];
 
+  const isSticker = reply.media?.mediaType === 'sticker' || 
+                    fileName.toLowerCase().includes('sticker/') ||
+                    fileName.toLowerCase().includes('/sticker/');
+
   try {
-    imageAnalysis = await analyzeImage(fileName);
+    imageAnalysis = await analyzeImage(fileName, isSticker);
     
     logger.info('processImageFile', {
       message_id: reply.message_id,
       bucketName: reply.media?.bucketName,
       key: reply.media?.key,
+      is_sticker: isSticker,
       medical_relevance: imageAnalysis?.medical_relevance,
       has_table: imageAnalysis?.has_table,
       analysis_type: imageAnalysis?.medical_analysis ? 'medical' : 'general'
@@ -77,18 +82,18 @@ const processImageFile = async (fileName, reply) => {
     
     const invalidAnalysis = ['NOT_MEDICAL', 'QUALITY_INSUFFICIENT'];
     
-    // Generate presigned URL if medically relevant
-    if (imageAnalysis?.medical_relevance) {
+    // Generate presigned URL only if medically relevant AND not a sticker
+    if (imageAnalysis?.medical_relevance && !isSticker) {
       url = await generatePresignedUrl(reply.media.bucketName, reply.media.key);            
     }
     
     // Add appropriate text based on analysis
-    if (imageAnalysis?.has_table && imageAnalysis.table_data) {
+    if (!isSticker && imageAnalysis?.has_table && imageAnalysis.table_data) {
       messagesChat.push({
         type: 'text',
         text: imageAnalysis.table_data,
       });
-    } else if (imageAnalysis?.medical_analysis && !invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
+    } else if (!isSticker && imageAnalysis?.medical_analysis && !invalidAnalysis.some(tag => imageAnalysis.medical_analysis.includes(tag))) {
       messagesChat.push({
         type: 'text',
         text: imageAnalysis.medical_analysis,
@@ -102,7 +107,8 @@ const processImageFile = async (fileName, reply) => {
   } catch (error) {
     logger.error('processImageFile', error, {
       message_id: reply.message_id,
-      fileName: fileName ? fileName.split('/').pop() : 'unknown'
+      fileName: fileName ? fileName.split('/').pop() : 'unknown',
+      is_sticker: isSticker
     });
     messagesChat.push({
       type: 'text',
@@ -175,8 +181,8 @@ const processMediaFiles = async (code, reply, provider) => {
       fileName: safeFileName
     });
     
-    // Skip unsupported file types
-    if (fileName.toLowerCase().includes('.wbmp') || fileName.toLowerCase().includes('sticker')) {
+    // Skip only WBMP files (unsupported format)
+    if (fileName.toLowerCase().includes('.wbmp')) {
       logger.info('processMediaFiles_skip', {
         message_id: reply.message_id,
         fileName: safeFileName,
@@ -185,7 +191,15 @@ const processMediaFiles = async (code, reply, provider) => {
       continue;
     }
 
-    if (fileName.includes('image') || fileName.includes('document') || fileName.includes('application')) {
+    // Process images, documents, applications, and stickers as images
+    const isImageLike = fileName.includes('image') || 
+                        fileName.includes('document') || 
+                        fileName.includes('application') ||
+                        reply.media?.mediaType === 'sticker' ||
+                        fileName.toLowerCase().includes('sticker/') ||
+                        fileName.toLowerCase().includes('/sticker/');
+
+    if (isImageLike) {
       const { messagesChat: imageMessages, url: imageUrl } = await processImageFile(fileName, reply);
       messagesChat.push(...imageMessages);
       if (imageUrl) url = imageUrl;

package/lib/helpers/qrHelper.js

@@ -1,4 +1,5 @@
 const qrcode = require('qrcode');
+const { logger } = require('../utils/logger');
 
 
 async function generateQRBuffer(text) {
@@ -6,7 +7,7 @@ async function generateQRBuffer(text) {
     const qrBuffer = await qrcode.toBuffer(text, { type: 'image/png' });
     return qrBuffer;
   } catch (err) {
-    console.error('Error generating QR code:', err.stack);
+    logger.error('Error generating QR code', { error: err.message, stack: err.stack });
     throw err;
   }
 }

package/lib/helpers/twilioMediaProcessor.js

@@ -5,37 +5,55 @@ const {
   getMediaTypeFromContentType,
   extractTitle
 } = require('./twilioHelper');
-const { validateMedia } = require('../utils/mediaValidator');
 const { generatePresignedUrl } = require('../config/awsConfig');
-const { addRecord, getRecordByFilter } = require('../services/airtableService');
+const { addLinkedRecord } = require('../services/airtableService');
 const { Monitoreo_ID } = require('../config/airtableConfig');
-
-const ensureLogger = (logger) => {
-  if (!logger) return console;
-  const fallback = {};
-  for (const level of ['info', 'warn', 'error', 'debug']) {
-    fallback[level] = typeof logger[level] === 'function' ? logger[level].bind(logger) : console[level].bind(console);
-  }
-  return fallback;
-};
+const { validateMedia } = require('../utils/mediaValidator');
+const { logger } = require('../utils/logger');
 
 const normalizeMediaType = (type) => {
   if (!type || typeof type !== 'string') return 'document';
   return type.replace(/Message$/i, '').replace(/WithCaption$/i, '').toLowerCase();
 };
 
-async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
-  if (!twilioMessage) return [];
+async function uploadMediaToAirtable(whatsappId, mediaUrl, baseID, tableName) {
+  if (!baseID) {
+    logger.debug('[uploadMediaToAirtable] Base ID not configured; skipping Airtable upload');
+    return;
+  }
+
+  try {
+    await addLinkedRecord(
+      baseID,
+      tableName,
+      {
+        estudios: [{ url: mediaUrl }],
+        combined_estudios: [{ url: mediaUrl }]
+      },
+      {
+        referenceTable: 'estado_general',
+        referenceFilter: `whatsapp_id = "${whatsappId}"`,
+        linkFieldName: 'patient_id'
+      }
+    );
+    
+    logger.debug('[uploadMediaToAirtable] Successfully uploaded media to estudios table', { whatsappId });
+  } catch (error) {
+    logger.warn('[uploadMediaToAirtable] Failed to upload media to estudios table', { whatsappId, error: error?.message || error });
+    throw error;
+  }
+}
 
-  const log = ensureLogger(logger);
+async function processTwilioMediaMessage(twilioMessage, bucketName) {
+  if (!twilioMessage) return [];
   const numMedia = parseInt(twilioMessage.NumMedia || '0', 10);
   if (!numMedia || numMedia <= 0) {
-    log.debug && log.debug('[TwilioMedia] No media detected in message');
+    logger.debug('[TwilioMedia] No media detected in message');
     return [];
   }
 
   if (!bucketName) {
-    log.warn && log.warn('[TwilioMedia] AWS bucket not configured; skipping media processing');
+    logger.warn('[TwilioMedia] AWS bucket not configured; skipping media processing');
     return [];
   }
 
@@ -50,25 +68,25 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
     const contentType = twilioMessage[`MediaContentType${i}`];
 
     if (!mediaUrl || !contentType) {
-      log.warn && log.warn('[TwilioMedia] Missing media URL or content type', { index: i });
+      logger.warn('[TwilioMedia] Missing media URL or content type', { index: i });
       continue;
     }
 
-    log.info && log.info('[TwilioMedia] Processing media item', { index: i, contentType, mediaUrl });
+    logger.info('[TwilioMedia] Processing media item', { index: i, contentType, mediaUrl });
 
     let mediaBuffer;
     try {
-      mediaBuffer = await downloadMediaFromTwilio(mediaUrl, log);
+      mediaBuffer = await downloadMediaFromTwilio(mediaUrl, logger);
     } catch (error) {
-      log.error && log.error('[TwilioMedia] Failed to download media', { index: i, error: error?.message || error });
+      logger.error('[TwilioMedia] Failed to download media', { index: i, error: error?.message || error });
       continue;
     }
 
     const validationResult = validateMedia(mediaBuffer, contentType);
     if (!validationResult.valid) {
-      log.warn && log.warn('[TwilioMedia] Media validation warning', { index: i, message: validationResult.message });
+      logger.warn('[TwilioMedia] Media validation warning', { index: i, message: validationResult.message });
     } else {
-      log.debug && log.debug('[TwilioMedia] Media validation passed', { index: i, message: validationResult.message });
+      logger.debug('[TwilioMedia] Media validation passed', { index: i, message: validationResult.message });
     }
 
     const helperMediaType = getMediaTypeFromContentType(contentType);
@@ -91,7 +109,7 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
         derivedMediaType
       );
     } catch (error) {
-      log.error && log.error('[TwilioMedia] Failed to upload media to S3', { index: i, error: error?.message || error });
+      logger.error('[TwilioMedia] Failed to upload media to S3', { index: i, error: error?.message || error });
       continue;
     }
 
@@ -117,25 +135,17 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
       const url = await generatePresignedUrl(bucketName, key);
       item.metadata.presignedUrl = url;
 
-      if (Monitoreo_ID) {
-        const patient = await getRecordByFilter(Monitoreo_ID, 'estado_general', `whatsapp_id = "${code}"`);
-        const patientId = Array.isArray(patient) && patient.length > 0 ? [patient[0].recordID || patient[0].recordId || patient[0].record_id] : [];
-        await addRecord(Monitoreo_ID, 'estudios', [{
-          fields: {
-            estudios: [{ url }],
-            combined_estudios: [{ url }],
-            patient_id: patientId
-          }
-        }]);
+      if (derivedMediaType !== 'sticker') {
+        await uploadMediaToAirtable(code, url, Monitoreo_ID, 'estudios');
       }
     } catch (error) {
-      log.warn && log.warn('[TwilioMedia] Failed to update Airtable with media reference', { index: i, error: error?.message || error });
+      logger.warn('[TwilioMedia] Failed to update Airtable with media reference', { index: i, error: error?.message || error });
     }
 
     mediaItems.push(item);
   }
 
-  console.log('[TwilioMedia] Completed processing', {
+  logger.info('[TwilioMedia] Completed processing', {
     from: code,
     itemsStored: mediaItems.length,
     bucket: bucketName

package/lib/helpers/whatsappHelper.js

@@ -1,4 +1,5 @@
 const moment = require('moment-timezone');
+const { logger } = require('../utils/logger');
 
 
 function delay(ms) {
@@ -7,7 +8,7 @@ function delay(ms) {
 
 
 function formatCode(codeBase) {
-  console.log(`formatCode ${codeBase}`);
+  logger.info(`formatCode ${codeBase}`);
 
   const [number, domain] = codeBase.split('@');
     
@@ -50,7 +51,7 @@ function calculateDelay(sendTime, timeZone) {
     const delay = sendMoment.diff(now) + randomDelay;
 
     // Log the calculated details for debugging
-    console.log(
+    logger.info(
       'Scheduled Time:', sendMoment.format(), 
       'Current Time:', now.format(), 
       'Delay (minutes):', delay / 60000, 

package/lib/index.js

@@ -25,9 +25,9 @@ const {
 } = require('./services/preprocessingHooks');
 const { 
   requestIdMiddleware, 
-  getRequestId, 
-  logger 
+  getRequestId
 } = require('./middleware/requestId');
+const { logger } = require('./utils/logger');
 
 /**
  * Main Nexus class that orchestrates all components
@@ -39,7 +39,7 @@ class Nexus {
     try {
       setDefaultInstance(this.messaging);
     } catch (err) {
-      console.warn('[Nexus] Failed to set default messaging instance:', err?.message || err);
+      logger.warn('[Nexus] Failed to set default messaging instance:', err?.message || err);
     }
     this.storage = null;
     this.messageParser = null;
@@ -92,11 +92,10 @@ class Nexus {
         }
       }
     } catch (e) {
-      console.warn('Warning: failed to auto-configure template providers:', e?.message || e);
+      logger.warn('Warning: failed to auto-configure template providers:', e?.message || e);
     }
 
-
-    // Convenience: handle mongoUri early (before storage connect)
+    // Handle mongoUri early (before storage connect)
     try {
       if (options.mongoUri) {
         if (storage === 'mongo') {
@@ -104,12 +103,11 @@ class Nexus {
             storageConfig.mongoUri = options.mongoUri;
           }
         } else {
-          // If not using MongoStorage but a URI is provided, initialize default mongoose connection
           await this.messaging.initializeMongoDB(options.mongoUri);
         }
       }
     } catch (dbErr) {
-      console.warn('[Nexus] mongo convenience warning:', dbErr?.message || dbErr);
+      logger.warn('[Nexus] mongo convenience warning:', dbErr?.message || dbErr);
     }
 
     // Initialize storage if provided
@@ -119,9 +117,8 @@ class Nexus {
         if (typeof storage === 'string') {
           this.storage = createStorage(storage, storageConfig || {});
         } else if (typeof storage === 'object' && (storage.saveMessage || storage.saveInteractive)) {
-          this.storage = storage; // external adapter instance
+          this.storage = storage;
         } else {
-          // default to mongo if truthy but not recognized
           this.storage = createStorage('mongo', storageConfig || {});
         }
         if (this.storage && typeof this.storage.connect === 'function') {
@@ -129,7 +126,7 @@ class Nexus {
         }
         this.messaging.setMessageStorage(this.storage);
       } catch (e) {
-        console.warn('Warning: storage initialization failed:', e?.message || e);
+        logger.warn('Warning: storage initialization failed:', e?.message || e);
       }
     }
 
@@ -150,7 +147,7 @@ class Nexus {
           llmConfigModule.setOpenAIClient(providerInstance.getClient());
         }
       } catch (err) {
-        console.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
+        logger.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
       }
     }
 
@@ -171,7 +168,7 @@ class Nexus {
         runtimeConfig.set('AIRTABLE_API_KEY', options.airtable.apiKey);
       }
     } catch (cfgErr) {
-      console.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
+      logger.warn('[Nexus] convenience config warning:', cfgErr?.message || cfgErr);
     }
 
 
@@ -195,7 +192,7 @@ class Nexus {
         }
       }
     } catch (e) {
-      console.warn('Warning: failed to configure assistants:', e?.message || e);
+      logger.warn('Warning: failed to configure assistants:', e?.message || e);
     }
 
     this.isInitialized = true;

package/lib/interactive/index.js

@@ -1,6 +1,7 @@
 
 const { toTwilioContent } = require('./twilioMapper');
 const { registerFlow, getFlow, listFlows, registerInteractiveHandler, listInteractiveHandlers } = require('./registry');
+const { logger } = require('../utils/logger');
 
 async function sendInteractive(nexusOrMessaging, params) {
   const { code, spec, id, variables } = params || {};
@@ -28,16 +29,6 @@ async function sendInteractive(nexusOrMessaging, params) {
   throw new Error('Interactive/flows not supported for this provider');
 }
 
-module.exports = {
-  registerFlow,
-  getFlow,
-  listFlows,
-  sendInteractive,
-  registerInteractiveHandler,
-  attachInteractiveRouter
-};
-
-
 function _matchInteractive(match, interactive) {
   if (!match) return true;
   if (!interactive) return false;
@@ -76,7 +67,7 @@ function attachInteractiveRouter(nexusOrMessaging) {
           await handler(messageData, messaging);
         }
       } catch (e) {
-        console.warn('Interactive handler error:', e && e.message || e);
+        logger.warn('Interactive handler error:', e && e.message || e);
       }
     }
   };
@@ -84,3 +75,12 @@ function attachInteractiveRouter(nexusOrMessaging) {
   bus.on('interactive:received', handler);
   return () => bus.off && bus.off('interactive:received', handler);
 }
+
+module.exports = {
+  registerFlow,
+  getFlow,
+  listFlows,
+  sendInteractive,
+  registerInteractiveHandler,
+  attachInteractiveRouter
+};

package/lib/middleware/requestId.js

@@ -1,41 +1,36 @@
 const { AsyncLocalStorage } = require('async_hooks');
 const { v4: uuidv4 } = require('uuid');
+const { setRequestIdGetter } = require('../utils/logger');
 
 const requestContext = new AsyncLocalStorage();
 
 function getRequestId() {
   const store = requestContext.getStore();
-  return store?.requestId || 'no-context';
+  return store?.requestId || null;
 }
 
+setRequestIdGetter(getRequestId);
+
 function requestIdMiddleware(req, res, next) {
   const requestId = uuidv4().substring(0, 8);
   req.requestId = requestId;
   res.setHeader('X-Request-Id', requestId);
   
   requestContext.run({ requestId }, () => {
-    console.log(`[${requestId}] → ${req.method} ${req.path}`);
-    
     const startTime = Date.now();
+    
     res.on('finish', () => {
       const duration = Date.now() - startTime;
-      console.log(`[${requestId}] ← ${res.statusCode} ${req.method} ${req.path} (${duration}ms)`);
+      if (process.env.LOG_HTTP_REQUESTS === 'true') {
+        console.log(`[${requestId}] ${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`);
+      }
     });
     
     next();
   });
 }
 
-const logger = {
-  log: (...args) => console.log(`[${getRequestId()}]`, ...args),
-  error: (...args) => console.error(`[${getRequestId()}]`, ...args),
-  warn: (...args) => console.warn(`[${getRequestId()}]`, ...args),
-  info: (...args) => console.info(`[${getRequestId()}]`, ...args),
-  debug: (...args) => console.debug(`[${getRequestId()}]`, ...args)
-};
-
 module.exports = { 
   requestIdMiddleware, 
-  getRequestId,
-  logger 
+  getRequestId
 };

package/lib/models/messageModel.js

@@ -2,6 +2,7 @@ const mongoose = require('mongoose');
 const moment = require('moment-timezone');
 const { getRecordByFilter } = require('../services/airtableService');
 const { Monitoreo_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 
 const messageSchema = new mongoose.Schema({
@@ -79,7 +80,7 @@ async function getClinicalContext(whatsappId) {
     }
     return null;
   } catch (error) {
-    console.error('Error fetching clinical context from Airtable:', error);
+    logger.error('Error fetching clinical context from Airtable:', error);
     return null;
   }
 }
@@ -116,9 +117,9 @@ async function insertMessage(values) {
       { upsert: true, new: true }
     );
 
-    console.log('[MongoStorage] Message inserted or updated successfully');
+    logger.info('[MongoStorage] Message inserted or updated successfully');
   } catch (err) {
-    console.error('[MongoStorage] Error inserting message:', err);
+    logger.error('[MongoStorage] Error inserting message:', err);
     throw err;
   }
 }
@@ -173,7 +174,7 @@ async function getContactDisplayName(contactNumber) {
       return contactNumber;
     }
   } catch (error) {
-    console.error('[MongoStorage] Error fetching display name for ${contactNumber}:', error);
+    logger.error('[MongoStorage] Error fetching display name for ${contactNumber}:', error);
     return contactNumber;
   }
 }

package/lib/providers/OpenAIAssistantsProvider.js

@@ -1,5 +1,6 @@
 const { OpenAI } = require('openai');
 const { retryWithBackoff } = require('../utils/retryHelper');
+const { logger } = require('../utils/logger');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
 const PROVIDER_NAME = 'OpenAIAssistantsProvider';
@@ -274,7 +275,7 @@ class OpenAIAssistantsProvider {
         const result = await assistant.executeTool(name, args);
         outputs.push({ tool_call_id: call.id, output: typeof result === 'string' ? result : JSON.stringify(result) });
       } catch (error) {
-        console.error('[OpenAIAssistantsProvider] Tool execution failed', error);
+        logger.error('[OpenAIAssistantsProvider] Tool execution failed', error);
         outputs.push({
           tool_call_id: call.id,
           output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
@@ -294,19 +295,19 @@ class OpenAIAssistantsProvider {
   async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
     try {
       const run = await this.getRun({ threadId: thread_id, runId: run_id });
-      console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
+      logger.info(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
 
       const failedStatuses = ['failed', 'expired', 'incomplete', 'errored'];
       if (failedStatuses.includes(run.status)) {
-        console.log(`Run failed. ${run.status} `);
-        console.log('Error:');
-        console.log(run);
+        logger.info(`Run failed. ${run.status} `);
+        logger.info('Error:');
+        logger.info(run);
         return {run, completed: false};
       } else if (run.status === 'cancelled') {
-        console.log('cancelled');
+        logger.info('cancelled');
         return {run, completed: true};
       } else if (run.status === 'requires_action') {
-        console.log('requires_action');
+        logger.info('requires_action');
         if (retryCount >= maxRetries) {
           return {run, completed: false};
         }
@@ -325,11 +326,11 @@ class OpenAIAssistantsProvider {
         await new Promise(resolve => setTimeout(resolve, 1000));
         return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
       } else {
-        console.log('Run completed.');
+        logger.info('Run completed.');
         return {run, completed: true};
       }
     } catch (error) {
-      console.error('Error checking run status:', error);
+      logger.error('Error checking run status:', error);
       return {run: null, completed: false};
     }
   }