@peopl-health/nexus 2.4.7 → 2.4.9

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');
 
 /**
@@ -66,7 +66,7 @@ const processImageFile = async (fileName, reply) => {
                     fileName.toLowerCase().includes('/sticker/');
 
   try {
-    imageAnalysis = await analyzeImage(fileName, isSticker);
+    imageAnalysis = await analyzeImage(fileName, isSticker, reply.media?.contentType);
     
     logger.info('processImageFile', {
       message_id: reply.message_id,

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,28 +5,20 @@ const {
   getMediaTypeFromContentType,
   extractTitle
 } = require('./twilioHelper');
-const { validateMedia } = require('../utils/mediaValidator');
 const { generatePresignedUrl } = require('../config/awsConfig');
 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 uploadMediaToAirtable(whatsappId, mediaUrl, log, baseID, tableName) {
+async function uploadMediaToAirtable(whatsappId, mediaUrl, baseID, tableName) {
   if (!baseID) {
-    log.debug && log.debug('[uploadMediaToAirtable] Base ID not configured; skipping Airtable upload');
+    logger.debug('[uploadMediaToAirtable] Base ID not configured; skipping Airtable upload');
     return;
   }
 
@@ -45,25 +37,23 @@ async function uploadMediaToAirtable(whatsappId, mediaUrl, log, baseID, tableNam
       }
     );
     
-    log.debug && log.debug('[uploadMediaToAirtable] Successfully uploaded media to estudios table', { whatsappId });
+    logger.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 });
+    logger.warn('[uploadMediaToAirtable] Failed to upload media to estudios table', { whatsappId, error: error?.message || error });
     throw error;
   }
 }
 
-async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
+async function processTwilioMediaMessage(twilioMessage, bucketName) {
   if (!twilioMessage) return [];
-
-  const log = ensureLogger(logger);
   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 [];
   }
 
@@ -78,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);
@@ -119,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;
     }
 
@@ -146,16 +136,16 @@ async function processTwilioMediaMessage(twilioMessage, logger, bucketName) {
       item.metadata.presignedUrl = url;
 
       if (derivedMediaType !== 'sticker') {
-        await uploadMediaToAirtable(code, url, log, Monitoreo_ID, 'estudios');
+        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};
     }
   }

package/lib/providers/OpenAIResponsesProvider.js

@@ -5,6 +5,7 @@ const {
   handleRequiresAction: handleRequiresActionUtil,
   transformToolsForResponsesAPI: transformToolsForResponsesAPIUtil
 } = require('./OpenAIResponsesProviderTools');
+const { logger } = require('../utils/logger');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
@@ -81,7 +82,7 @@ class OpenAIResponsesProvider {
       : messages;
     
     if (messages.length > DEFAULT_MAX_HISTORICAL_MESSAGES) {
-      console.warn(`[OpenAIResponsesProvider] Capped ${messages.length} → ${DEFAULT_MAX_HISTORICAL_MESSAGES} messages`);
+      logger.warn(`[OpenAIResponsesProvider] Capped ${messages.length} → ${DEFAULT_MAX_HISTORICAL_MESSAGES} messages`);
     }
     
     const allItems = this._conversationItems(messagesToProcess);
@@ -108,7 +109,7 @@ class OpenAIResponsesProvider {
     const totalBatches = Math.ceil(remainingItems.length / MAX_ITEMS_PER_BATCH);
     
     // Concise batch summary
-    console.log(`[OpenAIResponsesProvider] Batching: ${initialItems.length} (create) + ${remainingItems.length} (${totalBatches} batches) = ${totalItems} total`);
+    logger.info(`[OpenAIResponsesProvider] Batching: ${initialItems.length} (create) + ${remainingItems.length} (${totalBatches} batches) = ${totalItems} total`);
 
     const payload = this._cleanObject({
       metadata,
@@ -125,7 +126,7 @@ class OpenAIResponsesProvider {
         return await this._post('/conversations', payload);
       });
     } catch (error) {
-      console.error('[OpenAIResponsesProvider] Failed to create conversation:', error?.message || error);
+      logger.error('[OpenAIResponsesProvider] Failed to create conversation:', error?.message || error);
       throw error;
     }
 
@@ -134,7 +135,7 @@ class OpenAIResponsesProvider {
       try {
         await this._addItemsInBatches(conversation.id, remainingItems);
       } catch (error) {
-        console.error('[OpenAIResponsesProvider] Failed to add remaining messages. Conversation created with partial history:', error?.message || error);
+        logger.error('[OpenAIResponsesProvider] Failed to add remaining messages. Conversation created with partial history:', error?.message || error);
       }
     }
 
@@ -168,12 +169,12 @@ class OpenAIResponsesProvider {
           return await this._post(`/conversations/${id}/items`, { items: batchPayload });
         });
       } catch (error) {
-        console.error(`[OpenAIResponsesProvider] Batch ${batchNumber}/${totalBatches} failed:`, error?.message || error);
+        logger.error(`[OpenAIResponsesProvider] Batch ${batchNumber}/${totalBatches} failed:`, error?.message || error);
         throw error;
       }
     }
     
-    console.log(`[OpenAIResponsesProvider] Successfully added ${items.length} messages in ${totalBatches} batches`);
+    logger.info(`[OpenAIResponsesProvider] Successfully added ${items.length} messages in ${totalBatches} batches`);
   }
 
   /**
@@ -211,6 +212,12 @@ class OpenAIResponsesProvider {
 
     if (payloads.length === 0) return null;
 
+    if (payloads.length > MAX_ITEMS_PER_BATCH) {
+      logger.info(`[OpenAIResponsesProvider] Batching ${payloads.length} messages into chunks of ${MAX_ITEMS_PER_BATCH}`);
+      await this._addItemsInBatches(id, payloads, MAX_ITEMS_PER_BATCH);
+      return { batched: true, count: payloads.length };
+    }
+
     return this._retryWithRateLimit(async () => {
       if (this.conversations?.items?.create) {
         return await this.conversations.items.create(id, { items: payloads });
@@ -235,7 +242,7 @@ class OpenAIResponsesProvider {
       if (items.length === 0) return;
 
       if (deleteAll) {
-        console.log(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
+        logger.info(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
         for (const item of items) {
           await this.conversations.items.delete(item.id, {conversation_id: id});
         }
@@ -249,12 +256,12 @@ class OpenAIResponsesProvider {
         const hasOutput = functionOutputs.some(output => output.call_id === functionCall.call_id);
         
         if (!hasOutput) {
-          console.log(`[OpenAIResponsesProvider] Deleting orphaned function_call: ${functionCall.id} (${functionCall.call_id})`);
+          logger.info(`[OpenAIResponsesProvider] Deleting orphaned function_call: ${functionCall.id} (${functionCall.call_id})`);
           await this.conversations.items.delete(functionCall.id, {conversation_id: id});
         }
       }
     } catch (error) {
-      console.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
+      logger.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
     }
   }
 
@@ -288,7 +295,7 @@ class OpenAIResponsesProvider {
             toolOutputs = pendingOutputs;
           }
         } catch (error) {
-          console.warn('[OpenAIResponsesProvider] Error checking for pending function calls:', error?.message);
+          logger.warn('[OpenAIResponsesProvider] Error checking for pending function calls:', error?.message);
         }
       }
 
@@ -324,7 +331,7 @@ class OpenAIResponsesProvider {
         object: response.object || 'response',
       };
     } catch (error) {
-      console.error('[OpenAIResponsesProvider] Error running conversation:', error);
+      logger.error('[OpenAIResponsesProvider] Error running conversation:', error);
       throw error;
     }
   }
@@ -419,7 +426,7 @@ class OpenAIResponsesProvider {
   async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
     try {
       let 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})`);
 
       if (run.status === 'completed') {
         return {run, completed: true};
@@ -432,12 +439,12 @@ class OpenAIResponsesProvider {
       const needsFunctionCall = run.output?.some(item => item.type === 'function_call');
       if (needsFunctionCall && !actionHandled) {
         if (retryCount >= maxRetries) {
-          console.warn('[OpenAIResponsesProvider] Max retries reached while handling function calls');
+          logger.warn('[OpenAIResponsesProvider] Max retries reached while handling function calls');
           return {run, completed: false};
         }
 
         const outputs = await handleRequiresActionUtil(assistant, run);
-        console.log('[OpenAIResponsesProvider] Function call outputs:', outputs);
+        logger.info('[OpenAIResponsesProvider] Function call outputs:', outputs);
         
         if (outputs.length > 0) {
           try {
@@ -451,7 +458,7 @@ class OpenAIResponsesProvider {
             
             return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true);
           } catch (submitError) {
-            console.error('[OpenAIResponsesProvider] Error submitting tool outputs:', submitError);
+            logger.error('[OpenAIResponsesProvider] Error submitting tool outputs:', submitError);
             if (retryCount < maxRetries) {
               await new Promise(resolve => setTimeout(resolve, 2000));
               return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, false);
@@ -459,7 +466,7 @@ class OpenAIResponsesProvider {
             return {run, completed: false};
           }
         } else {
-          console.warn('[OpenAIResponsesProvider] Function calls detected but no outputs generated');
+          logger.warn('[OpenAIResponsesProvider] Function calls detected but no outputs generated');
           return {run, completed: false};
         }
       }
@@ -471,7 +478,7 @@ class OpenAIResponsesProvider {
 
       return {run, completed: false};
     } catch (error) {
-      console.error('[OpenAIResponsesProvider] Error checking run status:', error);
+      logger.error('[OpenAIResponsesProvider] Error checking run status:', error);
       return {run: null, completed: false};
     }
   }

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -1,6 +1,4 @@
-/**
- * Tool and function call handling utilities for OpenAIResponsesProvider
- */
+const { logger } = require('../utils/logger');
 
 /**
  * Execute a function call and return the output format
@@ -19,7 +17,7 @@ async function executeFunctionCall(assistant, call) {
       output: typeof result === 'string' ? result : JSON.stringify(result)
     };
   } catch (error) {
-    console.error('[OpenAIResponsesProvider] Tool execution failed', error);
+    logger.error('[OpenAIResponsesProvider] Tool execution failed', error);
     return {
       type: 'function_call_output',
       call_id: call.call_id,
@@ -46,7 +44,7 @@ async function handlePendingFunctionCalls(assistant, conversationItems) {
     return [];
   }
 
-  console.log(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
+  logger.info(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
   const outputs = [];
   for (const call of orphanedCalls) {
     outputs.push(await executeFunctionCall(assistant, call));