@peopl-health/nexus 2.4.6 → 2.4.8

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`);
   }
 
   /**
@@ -235,7 +236,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 +250,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 +289,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 +325,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 +420,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 +433,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 +452,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 +460,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 +472,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));

package/lib/providers/createProvider.js

@@ -1,5 +1,6 @@
 const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+const { logger } = require('../utils/logger');
 
 const PROVIDER_VARIANTS = {
   assistants: OpenAIAssistantsProvider,
@@ -10,7 +11,7 @@ const PROVIDER_VARIANTS = {
  * Returns the appropriate OpenAI provider implementation for the requested variant.
  */
 function createProvider(config = {}) {
-  console.log('Creating OpenAI provider with config:', config);
+  logger.debug('Creating OpenAI provider', { variant: config.variant || 'assistants' });
   const variant = (config.variant || config.providerVariant || config.llmVariant || 'assistants')
     .toString()
     .toLowerCase();

package/lib/services/airtableService.js

@@ -1,4 +1,5 @@
 const { airtable } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 
 async function addRecord(baseID, tableName, fields) {
@@ -6,10 +7,10 @@ async function addRecord(baseID, tableName, fields) {
     if (!airtable) throw new Error('Airtable not configured. Set AIRTABLE_API_KEY');
     const base = airtable.base(baseID);
     const record = await base(tableName).create(fields);
-    console.log('Record added at', tableName);
+    logger.info('Record added at', tableName);
     return record;
   } catch (error) {
-    console.error('Error adding record:', error);
+    logger.error('Error adding record:', error);
     throw error; 
   }
 }
@@ -30,7 +31,7 @@ async function getRecords(baseID, tableName) {
     });
     return records;
   } catch (error) {
-    console.error('Error fetching records:', error);
+    logger.error('Error fetching records:', error);
   }
 }
 
@@ -51,7 +52,7 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view')
     });
     return records;
   } catch (error) {
-    console.error(`Error fetching records by ${filter}:`, error);
+    logger.error(`Error fetching records by ${filter}:`, error);
   }
 }
 
@@ -74,7 +75,38 @@ async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
         
     return updatedRecords;
   } catch (error) {
-    console.error(`Error updating records by ${filter}:`, error);
+    logger.error(`Error updating records by ${filter}:`, error);
+  }
+}
+
+
+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;
   }
 }
 
@@ -82,5 +114,6 @@ module.exports = {
   addRecord,
   getRecords,
   getRecordByFilter,
-  updateRecordByFilter
+  updateRecordByFilter,
+  addLinkedRecord
 };

package/lib/services/assistantService.js

@@ -15,7 +15,7 @@ const { withTracing } = require('../utils/tracingDecorator.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');
+const { logger } = require('../utils/logger');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
@@ -136,9 +136,9 @@ const getAssistantById = (assistant_id, thread) => {
 
 const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   const findThread = await Thread.findOne({ code: code });
-  console.log('[createAssistant] findThread', findThread);
+  logger.info('[createAssistant] findThread', findThread);
   if (findThread && findThread.getConversationId()) {
-    console.log('[createAssistant] Thread already exists');
+    logger.info('[createAssistant] Thread already exists');
     const updateFields = { active: true, stopped: false };
     Thread.setAssistantId(updateFields, assistant_id);    
     await Thread.updateOne({ code: code }, { $set: updateFields });
@@ -146,7 +146,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   }
   
   const curRow = await getCurRow(Historial_Clinico_ID, code);
-  console.log('[createAssistant] curRow', curRow[0]);
+  logger.info('[createAssistant] curRow', curRow[0]);
   const nombre = curRow?.[0]?.['name'] || null;
   const patientId = curRow?.[0]?.['record_id'] || null;
 
@@ -175,7 +175,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const condition = { $or: [{ code: code }] };
   const options = { new: true, upsert: true };
   const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
-  console.log('[createAssistant] Updated thread:', updatedThread);
+  logger.info('[createAssistant] Updated thread:', updatedThread);
 
   // Delete previous thread
   if (force) {
@@ -188,12 +188,12 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
 const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) => {
   try {
     const thread = await Thread.findOne({ code: code });
-    console.log(thread);
+    logger.info(thread);
     if (thread === null) return null;
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     for (const message of inMessages) {
-      console.log(message);
+      logger.info(message);
       await provider.addMessage({
         threadId: thread.getConversationId(),
         role: role,
@@ -209,17 +209,17 @@ const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) =
     const assistant = getAssistantById(thread.getAssistantId(), thread);
     do {
       ({ output, completed } = await runAssistantAndWait({ thread, assistant }));
-      console.log(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
+      logger.info(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
       
       if (completed && output) break;
       if (retries < maxRetries) await new Promise(resolve => setTimeout(resolve, 2000));
       retries++;
     } while (retries <= maxRetries && (!completed || !output));
 
-    console.log('THE ANS IS', output);
+    logger.info('THE ANS IS', output);
     return output;
   } catch (error) {
-    console.log(error);
+    logger.info(error);
     return null;
   }
 };
@@ -254,7 +254,7 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
     null // no patientReply for instructions
   );
 
-  console.log('RUN RESPONSE', output);
+  logger.info('RUN RESPONSE', output);
   return output;
 };
 
@@ -290,14 +290,14 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   timings.getMessages = Date.now() - timings.getMessages;
   
   if (!patientReply) {
-    logger.log('[replyAssistantCore] No relevant data found for this assistant.');
+    logger.info('[replyAssistantCore] No relevant data found for this assistant.');
     return null;
   }
 
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   
   timings.processMessages = Date.now();
-  logger.log(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+  logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
   
   const processResults = await processThreadMessage(code, patientReply, provider);
   
@@ -308,7 +308,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   
   if (allMessagesToAdd.length > 0) {
     const threadId = thread.getConversationId();
-    logger.log(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
+    logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
     await provider.addMessage({ threadId, messages: allMessagesToAdd });
   }
   
@@ -319,10 +319,10 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   
   if (urls.length > 0) {
     timings.pdfCombination = Date.now();
-    logger.log(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+    logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
     const { pdfBuffer, processedFiles } = await combineImagesToPDF({ code });
     timings.pdfCombination = Date.now() - timings.pdfCombination;
-    logger.log(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+    logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
     
     if (pdfBuffer) {
       const key = `${code}-${Date.now()}-combined.pdf`;
@@ -353,7 +353,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   timings.runAssistant = Date.now() - timings.runAssistant;
   timings.total = Date.now() - startTotal;
 
-  logger.log('[Performance Breakdown]', {
+  logger.info('[Performance Breakdown]', {
     code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
     messageCount: patientReply.length,
     hasMedia: urls.length > 0,
@@ -378,7 +378,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
         run_assistant_ms: timings.runAssistant,
         total_ms: timings.total
       }
-    }).catch(err => console.error('[replyAssistantCore] Failed to store metrics:', err));
+    }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
   }
 
   return output;
@@ -398,7 +398,7 @@ const replyAssistant = withTracing(
 const switchAssistant = async (code, assistant_id) => {
   try {
     const thread = await Thread.findOne({ code: code });
-    console.log('Inside thread', thread);
+    logger.info('Inside thread', thread);
     if (thread === null) return;
 
     const variant = process.env.VARIANT || 'assistants';
@@ -412,7 +412,7 @@ const switchAssistant = async (code, assistant_id) => {
 
     await Thread.updateOne({ code }, { $set: updateFields });  
   } catch (error) {
-    console.log(error);
+    logger.info(error);
     return null;
   }
 };

package/lib/services/conversationService.js

@@ -1,6 +1,7 @@
 const { Message } = require('../models/messageModel');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 const { getRecordByFilter } = require('./airtableService');
+const { logger } = require('../utils/logger');
 
 
 const fetchConversationData = async (filter, skip, limit) => {
@@ -16,11 +17,11 @@ const fetchConversationData = async (filter, skip, limit) => {
         { read: { $exists: false } }
       ]
     };
-    console.log('Applying unread filter');
+    logger.info('Applying unread filter');
     break;
 
   case 'no-response':
-    console.log('Applying no-response filter');
+    logger.info('Applying no-response filter');
     break;
 
   case 'recent': {
@@ -30,18 +31,18 @@ const fetchConversationData = async (filter, skip, limit) => {
       is_group: false,
       createdAt: { $gt: yesterday }
     };
-    console.log('Applying recent filter (last 24 hours)');
+    logger.info('Applying recent filter (last 24 hours)');
     break;
   }
 
   case 'all':
   default:
     filterConditions = { is_group: false };
-    console.log('Applying all conversations filter');
+    logger.info('Applying all conversations filter');
     break;
   }
 
-  console.log('Executing aggregation pipeline...');
+  logger.info('Executing aggregation pipeline...');
   const aggregationStartTime = Date.now();
   
   let aggregationPipeline = [
@@ -77,7 +78,7 @@ const fetchConversationData = async (filter, skip, limit) => {
   const conversations = await Message.aggregate(aggregationPipeline);
 
   const aggregationTime = Date.now() - aggregationStartTime;
-  console.log(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
+  logger.info(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
 
   // Fetch names from Airtable and WhatsApp
   const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
@@ -89,7 +90,7 @@ const fetchConversationData = async (filter, skip, limit) => {
     map[patient.whatsapp_id] = patient.name;
     return map;
   }, {});
-  console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
+  logger.info(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
 
   const contactNames = await Message.aggregate([
     { $match: { is_group: false, from_me: false } },
@@ -110,7 +111,7 @@ const fetchConversationData = async (filter, skip, limit) => {
   }, {...airtableNameMap}) || airtableNameMap || {};
       
   // Fetch unread counts
-  console.log('Fetching unread counts using Message.aggregate');
+  logger.info('Fetching unread counts using Message.aggregate');
   const unreadCounts = await Message.aggregate([
     { 
       $match: { 
@@ -134,8 +135,8 @@ const fetchConversationData = async (filter, skip, limit) => {
     }
     return map;
   }, {}) || {};
-  console.log('unreadMap', JSON.stringify(unreadMap));
-  console.log('Number of conversations found:', conversations?.length || 0);
+  logger.info('unreadMap', JSON.stringify(unreadMap));
+  logger.info('Number of conversations found:', conversations?.length || 0);
       
   // Calculate total count for pagination
   let totalFilterConditions = { is_group: false };
@@ -193,14 +194,14 @@ const fetchConversationData = async (filter, skip, limit) => {
  * Processes conversations to prepare them for the response
  */
 const processConversations = async (conversations, nameMap, unreadMap) => {
-  console.log('Processing conversations for response...');
+  logger.info('Processing conversations for response...');
 
   let processedConversations = [];
   try {
     processedConversations = (conversations || []).map((conv, index) => {
       try {
         if (!conv || !conv.latestMessage) {
-          console.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
+          logger.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
           return {
             phoneNumber: conv?._id || 'unknown',
             name: 'Unknown',
@@ -245,7 +246,7 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
           lastMessageFromMe: conv?.latestMessage?.from_me || false
         };
       } catch (convError) {
-        console.error(`Error processing conversation ${index}:`, convError);
+        logger.error(`Error processing conversation ${index}:`, convError);
         return {
           phoneNumber: conv?._id || `error_${index}`,
           name: 'Error Processing',
@@ -260,11 +261,10 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
       }
     });
 
-    console.log(`Successfully processed ${processedConversations.length} conversations`);
+    logger.info(`Successfully processed ${processedConversations.length} conversations`);
   
   } catch (mappingError) {
-    console.error('Error in conversation mapping:', mappingError);
-    // Return empty conversations if mapping fails
+    logger.error('Error in conversation mapping:', mappingError);
     processedConversations = [];
   }
 

package/lib/services/preprocessingHooks.js

@@ -1,3 +1,5 @@
+const { logger } = require('../utils/logger');
+
 let preprocessingHandler = null;
 
 const setPreprocessingHandler = (handler) => {
@@ -16,7 +18,7 @@ const invokePreprocessingHandler = async (payload) => {
     const result = await preprocessingHandler(payload);
     return Boolean(result);
   } catch (error) {
-    console.warn('[PreprocessingHooks] Handler threw an error:', error?.message || error);
+    logger.warn('[PreprocessingHooks] Handler threw an error:', error?.message || error);
     return false;
   }
 };

package/lib/storage/MongoStorage.js

@@ -1,5 +1,6 @@
 const mongoose = require('mongoose');
 const runtimeConfig = require('../config/runtimeConfig');
+const { logger } = require('../utils/logger');
 
 /**
  * MongoDB storage interface for messages and interactions
@@ -34,7 +35,7 @@ class MongoStorage {
         useNewUrlParser: true,
         useUnifiedTopology: true
       });
-      console.log('MongoDB connected successfully');
+      logger.info('MongoDB connected successfully');
     } catch (error) {
       throw new Error(`MongoDB connection failed: ${error.message}`);
     }
@@ -46,10 +47,10 @@ class MongoStorage {
       const values = this.buildMessageValues(enrichedMessage);
       const { insertMessage } = require('../models/messageModel');
       await insertMessage(values);
-      console.log('[MongoStorage] Message stored');
+      logger.info('[MongoStorage] Message stored');
       return values;
     } catch (error) {
-      console.error('Error saving message:', error);
+      logger.error('Error saving message:', error);
       throw error;
     }
   }
@@ -64,23 +65,22 @@ class MongoStorage {
         return messageData;
       }
 
-      console.log('[MongoStorage] Detected Twilio media message', {
+      logger.info('[MongoStorage] Detected Twilio media message', {
         from: rawMessage.From,
         numMedia
       });
 
       const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME') || process.env.AWS_S3_BUCKET_NAME;
       if (!bucketName) {
-        console.warn('[MongoStorage] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
+        logger.warn('[MongoStorage] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
         return messageData;
       }
 
       const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor');
-      const { logger } = require('../utils/logger');
 
-      const mediaItems = await processTwilioMediaMessage(rawMessage, logger, bucketName);
+      const mediaItems = await processTwilioMediaMessage(rawMessage, bucketName);
       if (!mediaItems || mediaItems.length === 0) {
-        console.warn('[MongoStorage] Media processing returned no items');
+        logger.warn('[MongoStorage] Media processing returned no items');
         return messageData;
       }
 
@@ -91,7 +91,7 @@ class MongoStorage {
 
       rawMessage.__nexusMediaProcessed = true;
 
-      console.log('[MongoStorage] Media processed successfully', {
+      logger.info('[MongoStorage] Media processed successfully', {
         primaryType: mediaPayload.mediaType,
         mediaCount: mediaItems.length,
         s3Key: mediaPayload.key
@@ -107,7 +107,7 @@ class MongoStorage {
         caption: primary.caption || messageData.caption
       };
     } catch (error) {
-      console.error('[MongoStorage] Failed to enrich Twilio media message:', error);
+      logger.error('[MongoStorage] Failed to enrich Twilio media message:', error);
       return messageData;
     }
   }
@@ -197,7 +197,7 @@ class MongoStorage {
         .sort({ createdAt: -1 })
         .limit(limit);
     } catch (error) {
-      console.error('Error getting messages:', error);
+      logger.error('Error getting messages:', error);
       throw error;
     }
   }
@@ -206,7 +206,7 @@ class MongoStorage {
     try {
       return await this.schemas.Thread.findOne({ code, active: true });
     } catch (error) {
-      console.error('Error getting thread:', error);
+      logger.error('Error getting thread:', error);
       throw error;
     }
   }
@@ -217,7 +217,7 @@ class MongoStorage {
       await thread.save();
       return thread;
     } catch (error) {
-      console.error('Error creating thread:', error);
+      logger.error('Error creating thread:', error);
       throw error;
     }
   }
@@ -230,7 +230,7 @@ class MongoStorage {
         { new: true }
       );
     } catch (error) {
-      console.error('Error updating thread:', error);
+      logger.error('Error updating thread:', error);
       throw error;
     }
   }