@peopl-health/nexus 2.4.7 → 2.4.9-fix-pdf-processing

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));

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,7 @@ 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);
   }
 }
 

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;
 };
 
@@ -273,33 +273,48 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const timings = {};
   const startTotal = Date.now();
   
-  timings.getThread = Date.now();
-  const thread = thread_ || await withTracing(getThread, 'get_thread_operation', 
+  const { result: thread, duration: getThreadMs } = await withTracing(
+    getThread, 
+    'get_thread_operation', 
     (threadCode) => ({ 
       'thread.code': threadCode,
       'operation.type': 'thread_retrieval',
       'thread.provided': !!thread_
-    })
+    }),
+    { returnTiming: true }
   )(code);
-  timings.getThread = Date.now() - timings.getThread;
+  timings.get_thread_ms = getThreadMs;
   
-  if (!thread) return null;
-
-  timings.getMessages = Date.now();
-  const patientReply = await getLastMessages(code);
-  timings.getMessages = Date.now() - timings.getMessages;
+  if (!thread_ && !thread) return null;
+  const finalThread = thread_ || thread;
+
+  const { result: patientReply, duration: getMessagesMs } = await withTracing(
+    getLastMessages,
+    'get_last_messages',
+    (code) => ({ 'thread.code': code }),
+    { returnTiming: true }
+  )(code);
+  timings.get_messages_ms = getMessagesMs;
   
   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);
+  const { result: processResults, duration: processMessagesMs } = await withTracing(
+    processThreadMessage,
+    'process_thread_messages',
+    (code, patientReply, provider) => ({
+      'messages.count': patientReply.length,
+      'thread.code': code
+    }),
+    { returnTiming: true }
+  )(code, patientReply, provider);
+  timings.process_messages_ms = processMessagesMs;
   
   const patientMsg = processResults.some(r => r.isPatient);
   const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
@@ -307,22 +322,28 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   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`);
+    const threadId = finalThread.getConversationId();
+    logger.info(`[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 Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
   await cleanupFiles(allTempFiles);
   
-  timings.processMessages = Date.now() - timings.processMessages;
-  
   if (urls.length > 0) {
-    timings.pdfCombination = Date.now();
-    logger.log(`[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] Processing ${urls.length} URLs for PDF combination`);
+    const { result: pdfResult, duration: pdfCombinationMs } = await withTracing(
+      combineImagesToPDF,
+      'combine_images_to_pdf',
+      ({ code }) => ({
+        'pdf.thread_code': code,
+        'pdf.url_count': urls.length
+      }),
+      { returnTiming: true }
+    )({ code });
+    timings.pdf_combination_ms = pdfCombinationMs;
+    const { pdfBuffer, processedFiles } = pdfResult;
+    logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
     
     if (pdfBuffer) {
       const key = `${code}-${Date.now()}-combined.pdf`;
@@ -337,48 +358,43 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     }
   }
 
-  if (!patientMsg || thread.stopped) return null;
+  if (!patientMsg || finalThread.stopped) return null;
 
-  timings.runAssistant = Date.now();
-  const assistant = getAssistantById(thread.getAssistantId(), thread);
-  const { run, output, completed, retries, predictionTimeMs } = await withTracing(
+  const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
+  const { result: runResult, duration: runAssistantMs } = await withTracing(
     runAssistantWithRetries,
     'run_assistant_with_retries',
     (thread, assistant, runConfig, patientReply) => ({
       'assistant.id': thread.getAssistantId(),
       'assistant.max_retries': DEFAULT_MAX_RETRIES,
       'assistant.has_patient_reply': !!patientReply
-    })
-  )(thread, assistant, runOptions, patientReply);
-  timings.runAssistant = Date.now() - timings.runAssistant;
-  timings.total = Date.now() - startTotal;
+    }),
+    { returnTiming: true }
+  )(finalThread, assistant, runOptions, patientReply);
+  timings.run_assistant_ms = runAssistantMs;
+  timings.total_ms = Date.now() - startTotal;
+  
+  const { run, output, completed, retries, predictionTimeMs } = runResult;
 
-  logger.log('[Performance Breakdown]', {
+  logger.info('[Assistant Reply Complete]', {
     code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
     messageCount: patientReply.length,
     hasMedia: urls.length > 0,
     retries,
-    time: `${timings.total}ms`
+    totalMs: timings.total_ms
   });
 
   if (output && predictionTimeMs) {
     await PredictionMetrics.create({
       message_id: `${code}-${Date.now()}`,
       numero: code,
-      assistant_id: thread.getAssistantId(),
-      thread_id: thread.getConversationId(),
+      assistant_id: finalThread.getAssistantId(),
+      thread_id: finalThread.getConversationId(),
       prediction_time_ms: predictionTimeMs,
       retry_count: retries,
       completed: completed,
-      timing_breakdown: {
-        get_thread_ms: timings.getThread,
-        get_messages_ms: timings.getMessages,
-        process_messages_ms: timings.processMessages,
-        pdf_combination_ms: timings.pdfCombination || 0,
-        run_assistant_ms: timings.runAssistant,
-        total_ms: timings.total
-      }
-    }).catch(err => console.error('[replyAssistantCore] Failed to store metrics:', err));
+      timing_breakdown: timings
+    }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
   }
 
   return output;
@@ -398,7 +414,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 +428,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;
   }
 };