@peopl-health/nexus 2.2.5 → 2.2.7

package/lib/controllers/conversationController.js

@@ -3,6 +3,8 @@ const { fetchConversationData, processConversations } = require('../services/con
 const { sendMessage } = require('../core/NexusMessaging');
 const { Thread } = require('../models/threadModel');
 const llmConfig = require('../config/llmConfig');
+const { Historial_Clinico_ID } = require('../config/airtableConfig');
+const { getRecordByFilter } = require('../services/airtableService');
 
 const Message = mongoose.models.Message;
 
@@ -301,6 +303,9 @@ const searchConversationsController = async (req, res) => {
       });
     }
 
+    const maxLimit = 100;
+    const parsedLimit = Math.min(parseInt(limit) || 50, maxLimit);
+
     console.log(`Searching conversations for query: "${query}"`);
     const searchStartTime = Date.now();
 
@@ -332,18 +337,61 @@ const searchConversationsController = async (req, res) => {
         messageCount: { $sum: 1 }
       }},
       { $sort: { 'latestMessage.createdAt': -1 } },
-      { $limit: parseInt(limit) }
+      { $limit: parsedLimit }
     ]);
 
     const searchTime = Date.now() - searchStartTime;
     console.log(`Search completed in ${searchTime}ms, found ${conversations.length} conversations`);
 
+    // Fetch names from Airtable and WhatsApp (same logic as fetchConversationData)
+    const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
+    let airtableNameMap = {};
+    let airtablePatientIdMap = {};
+    
+    if (phoneNumbers.length > 0) {
+      try {
+        // Batch phone numbers to avoid Airtable URL length limit (16,000 chars)
+        const BATCH_SIZE = 50;
+        const batches = [];
+        for (let i = 0; i < phoneNumbers.length; i += BATCH_SIZE) {
+          batches.push(phoneNumbers.slice(i, i + BATCH_SIZE));
+        }
+
+        const batchPromises = batches.map(batch => {
+          const formula = 'OR(' +
+            batch.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
+            ')';
+          return getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula).catch(error => {
+            console.error('Error fetching Airtable batch for search:', error);
+            return [];
+          });
+        });
+
+        const batchResults = await Promise.all(batchPromises);
+        const patientTable = batchResults.flat();
+
+        // Create both maps in a single iteration
+        patientTable.forEach(patient => {
+          if (patient && patient.whatsapp_id) {
+            airtableNameMap[patient.whatsapp_id] = patient.name;
+            if (patient.patient_id) {
+              airtablePatientIdMap[patient.whatsapp_id] = patient.patient_id;
+            }
+          }
+        });
+        console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable for search results (${batches.length} batches)`);
+      } catch (error) {
+        console.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', error);
+      }
+    }
+
     // Process conversations for response
     const processedConversations = conversations.map(conv => {
       if (!conv || !conv.latestMessage) {
         return {
           phoneNumber: conv?._id || 'unknown',
           name: 'Unknown',
+          patientId: airtablePatientIdMap[conv?._id] || null,
           lastMessage: '',
           lastMessageTime: new Date(),
           messageCount: 0,
@@ -375,7 +423,8 @@ const searchConversationsController = async (req, res) => {
 
       return {
         phoneNumber: conv._id,
-        name: conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+        name: airtableNameMap[conv._id] || conv?.latestMessage?.nombre_whatsapp || 'Unknown',
+        patientId: airtablePatientIdMap[conv._id] || null,
         lastMessage: conv?.latestMessage?.body || '',
         lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),
         messageCount: conv.messageCount || 0,

package/lib/providers/OpenAIAssistantsProvider.js

@@ -1,6 +1,8 @@
 const { OpenAI } = require('openai');
+const { retryWithBackoff } = require('../utils/retryHelper');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
+const PROVIDER_NAME = 'OpenAIAssistantsProvider';
 
 /**
  * Provider wrapper that targets the legacy Assistants (threads/runs) API surface.
@@ -41,35 +43,22 @@ class OpenAIAssistantsProvider {
   }
 
   /**
-   * Retry helper for rate limit errors
-   * Extracts wait time from error message and retries with exponential backoff
+   * Retry helper wrapper that uses shared retry logic
+   * @private
    */
-  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (error?.status === 429 || error?.code === 'rate_limit_exceeded') {
-        if (retryCount >= maxRetries) {
-          throw new Error(`Rate limit exceeded after ${maxRetries} retries: ${error.message}`);
-        }
-
-        let waitTime = 60;
-        const waitMatch = error?.error?.message?.match(/after (\d+\.?\d*) seconds?/i) || 
-                         error?.message?.match(/after (\d+\.?\d*) seconds?/i);
-        if (waitMatch) {
-          waitTime = Math.ceil(parseFloat(waitMatch[1])) + 1; // Add 1 second buffer
-        } else {
-          waitTime = 60 * Math.pow(2, retryCount);
-        }
-
-        console.log(`[OpenAIAssistantsProvider] Rate limit exceeded. Waiting ${waitTime} seconds before retry ${retryCount + 1}/${maxRetries}`);
-        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
-
-        return this._retryWithRateLimit(operation, maxRetries, retryCount + 1);
-      }
+  async _retryWithBackoff(operation, options = {}) {
+    return retryWithBackoff(operation, {
+      ...options,
+      providerName: PROVIDER_NAME,
+    });
+  }
 
-      throw error;
-    }
+  /**
+   * @deprecated Use _retryWithBackoff instead
+   * Kept for backward compatibility
+   */
+  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
+    return this._retryWithBackoff(operation, { maxRetries, retryCount });
   }
 
   async createConversation({ metadata, messages = [], toolResources } = {}) {

package/lib/providers/OpenAIResponsesProvider.js

@@ -1,4 +1,5 @@
 const { OpenAI } = require('openai');
+const { retryWithBackoff } = require('../utils/retryHelper');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
@@ -6,6 +7,7 @@ const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
 const MAX_ITEMS_ON_CREATE = 20;
 const MAX_ITEMS_PER_BATCH = 20;
 const DEFAULT_MAX_HISTORICAL_MESSAGES = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
+const PROVIDER_NAME = 'OpenAIResponsesProvider';
 
 /**
  * Provider wrapper that targets the Conversations + Responses API surface.
@@ -47,35 +49,22 @@ class OpenAIResponsesProvider {
   }
 
   /**
-   * Retry helper for rate limit errors
-   * Extracts wait time from error message and retries with exponential backoff
+   * Retry helper wrapper that uses shared retry logic
+   * @private
    */
-  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (error?.status === 429 || error?.code === 'rate_limit_exceeded') {
-        if (retryCount >= maxRetries) {
-          throw new Error(`Rate limit exceeded after ${maxRetries} retries: ${error.message}`);
-        }
-
-        let waitTime = 60;
-        const waitMatch = error?.error?.message?.match(/after (\d+\.?\d*) seconds?/i) || 
-                         error?.message?.match(/after (\d+\.?\d*) seconds?/i);
-        if (waitMatch) {
-          waitTime = Math.ceil(parseFloat(waitMatch[1])) + 1; // Add 1 second buffer
-        } else {
-          waitTime = 60 * Math.pow(2, retryCount);
-        }
-
-        console.log(`[OpenAIResponsesProvider] Rate limit exceeded. Waiting ${waitTime} seconds before retry ${retryCount + 1}/${maxRetries}`);
-        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
-
-        return this._retryWithRateLimit(operation, maxRetries, retryCount + 1);
-      }
+  async _retryWithBackoff(operation, options = {}) {
+    return retryWithBackoff(operation, {
+      ...options,
+      providerName: PROVIDER_NAME,
+    });
+  }
 
-      throw error;
-    }
+  /**
+   * @deprecated Use _retryWithBackoff instead
+   * Kept for backward compatibility
+   */
+  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
+    return this._retryWithBackoff(operation, { maxRetries, retryCount });
   }
 
   /**

package/lib/utils/index.js

@@ -1,7 +1,9 @@
 const { MessageParser } = require('./messageParser');
 const { logger } = require('./logger');
+const { retryWithBackoff } = require('./retryHelper');
 
 module.exports = {
   MessageParser,
-  logger
+  logger,
+  retryWithBackoff,
 };

package/lib/utils/retryHelper.js

@@ -0,0 +1,167 @@
+const { logger } = require('./logger');
+
+// Retry configuration
+const RETRY_CONFIG = {
+  rateLimit: {
+    maxRetries: 3,
+    baseWaitTime: 60,
+  },
+  serverError: {
+    maxRetries: 5,
+    baseWaitTime: 2,
+    maxWaitTime: 32, // seconds
+  },
+};
+
+/**
+ * Extract request ID from error object
+ * Handles various formats that OpenAI SDK might use
+ */
+function extractRequestId(error) {
+  if (!error) return null;
+  return error?.requestID || 
+         (error?.headers?.get ? error.headers.get('x-request-id') : null) ||
+         (error?.headers?.['x-request-id']) ||
+         null;
+}
+
+/**
+ * Calculate wait time with full jitter (exponential backoff with random jitter)
+ * Uses "full jitter" strategy: random(0, base * 2^retryCount)
+ * This is the recommended approach (AWS, Google Cloud best practices)
+ */
+function calculateWaitTime(config, retryCount, isRateLimit = false, error = null) {
+  let baseWaitTime;
+  
+  if (isRateLimit) {
+    const waitMatch = error?.error?.message?.match(/after (\d+\.?\d*) seconds?/i) || 
+                     error?.message?.match(/after (\d+\.?\d*) seconds?/i);
+    if (waitMatch) {
+      baseWaitTime = Math.ceil(parseFloat(waitMatch[1])) + 1;
+      return baseWaitTime;
+    }
+    baseWaitTime = config.baseWaitTime * Math.pow(2, retryCount);
+  } else {
+    baseWaitTime = Math.min(
+      config.baseWaitTime * Math.pow(2, retryCount),
+      config.maxWaitTime
+    );
+  }
+
+  return Math.ceil(Math.random() * baseWaitTime);
+}
+
+/**
+ * Check if error is retryable
+ * Returns true for rate limits, server errors (5xx), and network/timeout errors
+ */
+function isRetryableError(error) {
+  if (!error) return false;
+  
+  const status = error?.status;
+  const code = error?.code;
+  
+  if (status === 429 || code === 'rate_limit_exceeded') {
+    return true;
+  }
+  
+  if (status >= 500 && status < 600) {
+    return true;
+  }
+  
+  const networkErrorCodes = ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ECONNREFUSED', 'timeout'];
+  if (networkErrorCodes.includes(code) || error?.message?.includes('timeout')) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Create enhanced error with original error information preserved.
+ */
+function createRetryError(error, errorType, maxRetries, retryCount) {
+  const requestId = extractRequestId(error);
+  const enhancedMessage = `${errorType} after ${maxRetries} retries: ${error.message}${requestId ? ` (Request ID: ${requestId})` : ''}`;
+  
+  const finalError = new Error(enhancedMessage);
+  finalError.originalError = error;
+  finalError.status = error.status;
+  finalError.code = error.code;
+  finalError.requestID = requestId;
+  finalError.retryCount = retryCount;
+  return finalError;
+}
+
+/**
+ * Sleep helper - returns a promise that resolves after specified milliseconds.
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry helper for rate limit errors and server errors
+ * Extracts wait time from error message and retries with exponential backoff + full jitter
+ * Preserves original error information including requestID
+ */
+async function retryWithBackoff(operation, options = {}) {
+  const {
+    maxRetries = RETRY_CONFIG.serverError.maxRetries,
+    retryCount = 0,
+    providerName = 'OpenAIProvider',
+  } = options;
+
+  if (typeof operation !== 'function') {
+    throw new Error('Operation must be a function');
+  }
+
+  try {
+    return await operation();
+  } catch (error) {
+    const isRateLimit = error?.status === 429 || error?.code === 'rate_limit_exceeded';
+    const isRetryable = isRetryableError(error);
+    
+    if (isRetryable) {
+      const config = isRateLimit ? RETRY_CONFIG.rateLimit : RETRY_CONFIG.serverError;
+      const effectiveMaxRetries = isRateLimit ? RETRY_CONFIG.rateLimit.maxRetries : maxRetries;
+
+      if (retryCount >= effectiveMaxRetries) {
+        const errorType = isRateLimit ? 'Rate limit' : 'Server/Network error';
+        throw createRetryError(error, errorType, effectiveMaxRetries, retryCount);
+      }
+
+      const waitTime = calculateWaitTime(config, retryCount, isRateLimit, error);
+      const errorType = isRateLimit ? 'Rate limit exceeded' : `Server/Network error (${error?.status || error?.code || 'unknown'})`;
+      const requestId = extractRequestId(error);
+      
+      logger.warn({
+        provider: providerName,
+        errorType,
+        status: error?.status,
+        code: error?.code,
+        requestId,
+        retryCount: retryCount + 1,
+        maxRetries: effectiveMaxRetries,
+        waitTime,
+      }, `${errorType}. Retrying in ${waitTime}s (${retryCount + 1}/${effectiveMaxRetries})`);
+
+      await sleep(waitTime * 1000);
+
+      return retryWithBackoff(operation, { maxRetries, retryCount: retryCount + 1, providerName });
+    }
+
+    throw error;
+  }
+}
+
+module.exports = {
+  retryWithBackoff,
+  extractRequestId,
+  calculateWaitTime,
+  isRetryableError,
+  createRetryError,
+  sleep,
+  RETRY_CONFIG,
+};
+

package/package.json

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