@peopl-health/nexus 2.2.6 → 2.2.8

package/lib/controllers/assistantController.js

@@ -22,9 +22,12 @@ const activeAssistantController = async (req, res) => {
 
 const addInsAssistantController = async (req, res) => {
   const { code, instruction } = req.body;
-
+  
   try {
-    const ans = await addInsAssistant(code, instruction);
+    const variant = process.env.VARIANT || 'assistants';
+    const role = variant === 'responses' ? 'developer' : 'user';
+    
+    const ans = await addInsAssistant(code, instruction, role);
     if (ans) await sendMessage({code, body: ans, fileType: 'text'});
     return res.status(200).send({ message: 'Add instruction to the assistant' });
   } catch (error) {

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.6",
+  "version": "2.2.8",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",