@peopl-health/nexus 2.4.5 → 2.4.7

package/lib/helpers/llmsHelper.js

@@ -3,12 +3,13 @@ const fs = require('fs');
 const mime = require('mime-types');
 
 
-async function analyzeImage(imagePath) {
+async function analyzeImage(imagePath, isSticker = false) {
   try {
     const anthropicClient = llmConfig.anthropicClient;
     if (!anthropicClient || !anthropicClient.messages) {
       console.warn('[llmsHelper] Anthropics client not configured; skipping image analysis');
       return {
+        description: 'Image could not be analyzed - Anthropic client not configured',
         medical_analysis: 'QUALITY_INSUFFICIENT',
         medical_relevance: false,
         has_table: false,
@@ -16,10 +17,11 @@ async function analyzeImage(imagePath) {
       };
     }
 
-    // Skip WBMP images and stickers
-    if (imagePath.toLowerCase().includes('.wbmp') || imagePath.toLowerCase().includes('sticker')) {
-      console.log('Skipping WBMP image or sticker analysis:', imagePath);
+    // Skip only WBMP images (unsupported format)
+    if (imagePath.toLowerCase().includes('.wbmp')) {
+      console.log('Skipping WBMP image analysis:', imagePath);
       return {
+        description: 'Unsupported image format',
         medical_analysis: 'NOT_MEDICAL',
         medical_relevance: false,
         has_table: false,
@@ -29,9 +31,10 @@ async function analyzeImage(imagePath) {
     
     // Check MIME type
     const mimeType = mime.lookup(imagePath) || 'image/jpeg';
-    if (mimeType === 'image/vnd.wap.wbmp' || mimeType.includes('sticker')) {
+    if (mimeType === 'image/vnd.wap.wbmp') {
       console.log('Skipping image with MIME type:', mimeType);
       return {
+        description: 'Unsupported image format',
         medical_analysis: 'NOT_MEDICAL',
         medical_relevance: false,
         has_table: false,
@@ -42,7 +45,7 @@ async function analyzeImage(imagePath) {
     const imageBuffer = await fs.promises.readFile(imagePath);
     const base64Image = imageBuffer.toString('base64');
 
-    // Descrciption of the image
+    // Description of the image (for both stickers and regular images)
     const imageDescription = 'Describe the image in detail.';
     const messageDescription = await anthropicClient.messages.create({
       model: 'claude-sonnet-4-5',
@@ -69,6 +72,17 @@ async function analyzeImage(imagePath) {
     });
     const description = messageDescription.content[0].text;
 
+    // For stickers, skip medical analysis and table extraction
+    if (isSticker) {
+      return {
+        description: description,
+        medical_analysis: 'NOT_MEDICAL',
+        medical_relevance: false,
+        has_table: false,
+        table_data: null
+      };
+    }
+
     // Create a more specific prompt for table detection and extraction
     const tablePrompt = `Please analyze this image and respond in the following format:
 1. First, determine if there is a table in the image.

package/lib/helpers/processHelper.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;
@@ -198,36 +212,43 @@ const processMediaFiles = async (code, reply, provider) => {
   return { messagesChat, url, tempFiles };
 };
 
-const processIndividualMessage = async (code, reply, provider, thread) => {  
-  let tempFiles = [];
-  try {
-    const isPatient = reply.origin === 'patient';
-    const textMessages = processTextMessage(reply);
-    
-    const { messagesChat: mediaMessages, url, tempFiles: mediaFiles } = await processMediaFiles(code, reply, provider);
-    tempFiles = mediaFiles;
-    
-    const allMessages = [...textMessages, ...mediaMessages];
-    
-    if (allMessages.length > 0) {
-      await addMessageToThread(reply, allMessages, provider, thread);
-      await updateMessageRecord(reply, thread);
-    }
-    
-    return { isPatient, url };
-  } catch (error) {
-    logger.error('processIndividualMessage', error, {
-      message_id: reply.message_id,
-      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-      origin: reply.origin
-    });
-    await cleanupFiles(tempFiles);
-    return { isPatient: false, url: null };
-  } finally {
-    if (tempFiles.length > 0) {
-      await cleanupFiles(tempFiles);
-    }
-  }
+const processThreadMessage = async (code, replies, provider) => {
+  const replyArray = Array.isArray(replies) ? replies : [replies];
+  
+  const results = await Promise.all(
+    replyArray.map(async (reply, i) => {
+      let tempFiles = [];
+      try {
+        const isPatient = reply.origin === 'patient';
+        const [textMessages, mediaResult] = await Promise.all([
+          Promise.resolve(processTextMessage(reply)),
+          processMediaFiles(code, reply, provider)
+        ]);
+        
+        const { messagesChat: mediaMessages, url, tempFiles: mediaFiles } = mediaResult;
+        tempFiles = mediaFiles;
+        
+        const allMessages = [...textMessages, ...mediaMessages];
+        const role = reply.origin === 'patient' ? 'user' : 'assistant';
+        const messages = allMessages.map(content => ({ role, content }));
+        
+        logger.info('processThreadMessage', { 
+          index: i + 1, 
+          total: replyArray.length,
+          isPatient, 
+          hasUrl: !!url 
+        });
+        
+        return { isPatient, url, messages, reply, tempFiles };
+      } catch (error) {
+        logger.error('processThreadMessage', error, { message_id: reply.message_id, origin: reply.origin });
+        await cleanupFiles(tempFiles);
+        return { isPatient: false, url: null, messages: [], reply, tempFiles: [] };
+      }
+    })
+  );
+  
+  return results;
 };
 
 module.exports = {
@@ -235,5 +256,5 @@ module.exports = {
   processImageFile,
   processAudioFile,
   processMediaFiles,
-  processIndividualMessage
+  processThreadMessage
 };

package/lib/helpers/twilioMediaProcessor.js

@@ -7,7 +7,7 @@ const {
 } = 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) => {
@@ -24,6 +24,34 @@ const normalizeMediaType = (type) => {
   return type.replace(/Message$/i, '').replace(/WithCaption$/i, '').toLowerCase();
 };
 
+async function uploadMediaToAirtable(whatsappId, mediaUrl, log, baseID, tableName) {
+  if (!baseID) {
+    log.debug && log.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'
+      }
+    );
+    
+    log.debug && log.debug('[uploadMediaToAirtable] Successfully uploaded media to estudios table', { whatsappId });
+  } catch (error) {
+    log.warn && log.warn('[uploadMediaToAirtable] Failed to upload media to estudios table', { whatsappId, error: error?.message || error });
+    throw error;
+  }
+}
+
 async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
   if (!twilioMessage) return [];
 
@@ -117,16 +145,8 @@ 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, log, Monitoreo_ID, 'estudios');
       }
     } catch (error) {
       log.warn && log.warn('[TwilioMedia] Failed to update Airtable with media reference', { index: i, error: error?.message || error });

package/lib/providers/OpenAIAssistantsProvider.js

@@ -82,22 +82,28 @@ class OpenAIAssistantsProvider {
     await this.client.beta.threads.del(this._ensureId(threadId));
   }
 
-  async addMessage({ threadId, role = 'user', content, metadata }) {
-    const formattedContent = this._normalizeContent(content);
-
-    const payload = {
-      role,
-      content: formattedContent,
-      metadata,
-    };
-
-    if (payload.metadata && Object.keys(payload.metadata).length === 0) {
-      delete payload.metadata;
+  async addMessage({ threadId, messages, role = 'user', content, metadata }) {
+    const id = this._ensureId(threadId);
+    const messagesToAdd = messages || [{ role, content, metadata }];
+    
+    const results = [];
+    for (const msg of messagesToAdd) {
+      const formattedContent = this._normalizeContent(msg.content);
+      const payload = {
+        role: msg.role || 'user',
+        content: formattedContent,
+      };
+      
+      if (msg.metadata && Object.keys(msg.metadata).length > 0) {
+        payload.metadata = msg.metadata;
+      }
+      
+      const result = await this._retryWithRateLimit(() => 
+        this.client.beta.threads.messages.create(id, payload)
+      );
+      results.push(result);
     }
-
-    return this._retryWithRateLimit(() => 
-      this.client.beta.threads.messages.create(this._ensureId(threadId), payload)
-    );
+    return messages ? results : results[0];
   }
 
   async listMessages({ threadId, runId, order = 'desc', limit } = {}) {

package/lib/providers/OpenAIResponsesProvider.js

@@ -197,23 +197,26 @@ class OpenAIResponsesProvider {
     return await this._delete(`/conversations/${id}`);
   }
 
-  async addMessage({ threadId, role = 'user', content, metadata }) {
+  async addMessage({ threadId, messages, role = 'user', content, metadata }) {
     const id = this._ensurethreadId(threadId);
+    const messagesToAdd = messages || [{ role, content, metadata }];
     
-    const payload = this._cleanObject({
-      role,
-      content: this._normalizeContent(role, content),
-      type: 'message',
-    });
+    const payloads = messagesToAdd.map(msg => 
+      this._cleanObject({
+        role: msg.role || 'user',
+        content: this._normalizeContent(msg.role || 'user', msg.content),
+        type: 'message',
+      })
+    ).filter(p => p.content);
 
-    if (payload.content) {
-      return this._retryWithRateLimit(async () => {
-        if (this.conversations?.items?.create) {
-          return await this.conversations.items.create(id, {items: [payload]});
-        }
-        return await this._post(`/conversations/${id}/items`, {items: [payload]});
-      });
-    }
+    if (payloads.length === 0) return null;
+
+    return this._retryWithRateLimit(async () => {
+      if (this.conversations?.items?.create) {
+        return await this.conversations.items.create(id, { items: payloads });
+      }
+      return await this._post(`/conversations/${id}/items`, { items: payloads });
+    });
   }
 
   async listMessages({ threadId, order = 'desc', limit } = {}) {

package/lib/services/airtableService.js

@@ -78,9 +78,41 @@ async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
   }
 }
 
+
+async function addLinkedRecord(baseID, targetTable, fields, linkConfig) {
+  if (!baseID) {
+    throw new Error('[addLinkedRecord] Base ID is required');
+  }
+
+  try {
+    if (linkConfig) {
+      const { referenceTable, referenceFilter, linkFieldName } = linkConfig;
+      
+      const base = airtable.base(baseID);
+      const referenceRecords = await base(referenceTable).select({
+        filterByFormula: referenceFilter
+      }).firstPage();
+      
+      if (linkFieldName && referenceRecords && referenceRecords.length > 0) {
+        const recordId = referenceRecords[0].id;
+        if (recordId) {
+          fields[linkFieldName] = [recordId];
+        }
+      }
+    }
+    
+    const record = await addRecord(baseID, targetTable, [{ fields }]);
+    return record;
+  } catch (error) {
+    console.error('[addLinkedRecord] Error adding linked record:', error);
+    throw error;
+  }
+}
+
 module.exports = {
   addRecord,
   getRecords,
   getRecordByFilter,
-  updateRecordByFilter
+  updateRecordByFilter,
+  addLinkedRecord
 };

package/lib/services/assistantService.js

@@ -12,8 +12,8 @@ const { getCurRow } = require('../helpers/assistantHelper.js');
 const { runAssistantAndWait, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
 const { getThread, getThreadInfo } = require('../helpers/threadHelper.js');
 const { withTracing } = require('../utils/tracingDecorator.js');
-const { processIndividualMessage } = require('../helpers/processHelper.js');
-const { getLastMessages } = require('../helpers/messageHelper.js');
+const { processThreadMessage } = require('../helpers/processHelper.js');
+const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { logger } = require('../middleware/requestId');
 
@@ -298,19 +298,24 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   
   timings.processMessages = Date.now();
   logger.log(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
-  const results = await Promise.all(
-    patientReply.map((reply, i) => 
-      processIndividualMessage(code, reply, provider, thread)
-        .then(result => {
-          logger.log(`[replyAssistantCore] Message ${i + 1}/${patientReply.length}: isPatient=${result.isPatient}, hasUrl=${!!result.url}`);
-          return result;
-        })
-    )
-  );
-  timings.processMessages = Date.now() - timings.processMessages;
   
-  const patientMsg = results.some(r => r.isPatient);
-  const urls = results.filter(r => r.url).map(r => ({ url: r.url }));
+  const processResults = await processThreadMessage(code, patientReply, provider);
+  
+  const patientMsg = processResults.some(r => r.isPatient);
+  const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
+  const allMessagesToAdd = processResults.flatMap(r => r.messages || []);
+  const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
+  
+  if (allMessagesToAdd.length > 0) {
+    const threadId = thread.getConversationId();
+    logger.log(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
+    await provider.addMessage({ threadId, messages: allMessagesToAdd });
+  }
+  
+  await Promise.all(processResults.map(r => updateMessageRecord(r.reply, thread)));
+  await cleanupFiles(allTempFiles);
+  
+  timings.processMessages = Date.now() - timings.processMessages;
   
   if (urls.length > 0) {
     timings.pdfCombination = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",