@peopl-health/nexus 2.5.7 → 2.5.9

package/examples/assistants/DoctorScheduleAssistant.js

@@ -39,7 +39,7 @@ class DoctorScheduleAssistant extends BaseAssistant {
         }
       },
       handler: async (payload = {}) => {
-        logger.info('[DoctorScheduleAssistant] storePatientAppointment', payload);
+        logger.info('[DoctorScheduleAssistant] storePatientAppointment', { payload });
 
         if (!payload.contact_number || !payload.appointment_type) {
           return JSON.stringify({
@@ -59,7 +59,7 @@ class DoctorScheduleAssistant extends BaseAssistant {
           notes: payload.notes || null
         };
 
-        logger.info('[DoctorScheduleAssistant] Appointment captured', appointment);
+        logger.info('[DoctorScheduleAssistant] Appointment captured', { appointment });
 
         return JSON.stringify({ success: true, appointment });
       }

package/lib/controllers/assistantController.js

@@ -35,7 +35,7 @@ const addInsAssistantController = async (req, res) => {
 };
 
 const addMsgAssistantController = async (req, res) => {
-  const { code, messages, role = 'user', reply = false } = req.body;
+  const { code, messages, role = 'system', reply = false } = req.body;
 
   try {
     const assistantReply = await addMsgAssistant(code, messages, role, reply);

package/lib/controllers/threadController.js

@@ -0,0 +1,151 @@
+const { Thread } = require('../models/threadModel');
+const { logger } = require('../utils/logger');
+
+/**
+ * Update review status for a specific thread by code
+ */
+const updateThreadReviewStatus = async (req, res) => {
+  try {
+    const { code } = req.params;
+    const { review } = req.body;
+
+    if (typeof review !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'Review status must be a boolean value'
+      });
+    }
+
+    const thread = await Thread.findOneAndUpdate(
+      { code },
+      { review },
+      { new: true }
+    );
+
+    if (!thread) {
+      return res.status(404).json({
+        success: false,
+        message: 'Thread not found'
+      });
+    }
+
+    logger.info('[updateThreadReviewStatus] Thread review status updated', { 
+      code: code.substring(0, 3) + '***' + code.slice(-4), 
+      review 
+    });
+
+    res.json({
+      success: true,
+      message: 'Thread review status updated successfully',
+      thread: {
+        code: thread.code,
+        review: thread.review,
+        updatedAt: thread.updatedAt
+      }
+    });
+  } catch (error) {
+    logger.error('[updateThreadReviewStatus] Error updating thread review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+/**
+ * Update review status for all threads at once
+ */
+const updateAllThreadsReviewStatus = async (req, res) => {
+  try {
+    const { review } = req.body;
+
+    if (typeof review !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'Review status must be a boolean value'
+      });
+    }
+
+    const result = await Thread.updateMany(
+      {},
+      { review }
+    );
+
+    logger.info('[updateAllThreadsReviewStatus] All threads review status updated', { 
+      review, 
+      modifiedCount: result.modifiedCount 
+    });
+
+    res.json({
+      success: true,
+      message: `Successfully updated review status for ${result.modifiedCount} threads`,
+      modifiedCount: result.modifiedCount,
+      review
+    });
+  } catch (error) {
+    logger.error('[updateAllThreadsReviewStatus] Error updating all threads review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+/**
+ * Get threads by review status
+ */
+const getThreadsByReviewStatus = async (req, res) => {
+  try {
+    const { review } = req.query;
+    const { page = 1, limit = 20 } = req.query;
+
+    const filter = {};
+    if (review !== undefined) {
+      filter.review = review === 'true';
+    }
+
+    const skip = (parseInt(page) - 1) * parseInt(limit);
+    
+    const threads = await Thread.find(filter)
+      .select('code review active stopped createdAt updatedAt')
+      .sort({ updatedAt: -1 })
+      .skip(skip)
+      .limit(parseInt(limit));
+
+    const total = await Thread.countDocuments(filter);
+
+    logger.info('[getThreadsByReviewStatus] Retrieved threads by review status', { 
+      filter, 
+      count: threads.length, 
+      total,
+      page: parseInt(page),
+      limit: parseInt(limit)
+    });
+
+    res.json({
+      success: true,
+      threads: threads.map(thread => ({
+        ...thread.toObject(),
+        code: thread.code.substring(0, 3) + '***' + thread.code.slice(-4)
+      })),
+      pagination: {
+        page: parseInt(page),
+        limit: parseInt(limit),
+        total,
+        totalPages: Math.ceil(total / parseInt(limit))
+      }
+    });
+  } catch (error) {
+    logger.error('[getThreadsByReviewStatus] Error retrieving threads by review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+module.exports = {
+  updateThreadReviewStatus,
+  updateAllThreadsReviewStatus,
+  getThreadsByReviewStatus
+};

package/lib/core/NexusMessaging.js

@@ -1,9 +1,11 @@
 const { airtable, getBase } = require('../config/airtableConfig');
 const { Message } = require('../models/messageModel');
+const { Thread } = require('../models/threadModel');
 const { addMsgAssistant, replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
 const runtimeConfig = require('../config/runtimeConfig');
 const { hasPreprocessingHandler, invokePreprocessingHandler } = require('../services/preprocessingHooks');
+const { ensureThreadExists } = require('../helpers/threadHelper');
 const { logger } = require('../utils/logger');
 
 const mongoose = require('mongoose');
@@ -312,7 +314,7 @@ class NexusMessaging {
     }
     
     if (messageData.origin !== 'assistant' && messageData.code && messageContent) {
-      const skipSystemMessage = messageData._fromConversationReply === true;
+      const skipSystemMessage = messageData._fromConversationReply === true || providerStoresMessage;
       await addMsgAssistant(
         messageData.code,
         [messageContent],
@@ -354,6 +356,24 @@ class NexusMessaging {
 
     const chatId = messageData.from || messageData.From;
 
+    // Ensure thread exists in background for new numbers
+    if (chatId) {
+      ensureThreadExists(chatId);
+      
+      // Reset review status to false when new message arrives
+      try {
+        await Thread.updateOne(
+          { code: chatId },
+          { review: false }
+        );
+      } catch (error) {
+        logger.error('[processIncomingMessage] Failed to reset thread review status', { 
+          code: chatId.substring(0, 3) + '***' + chatId.slice(-4), 
+          error 
+        });
+      }
+    }
+
     if (chatId && hasPreprocessingHandler()) {
       const stop = await invokePreprocessingHandler({
         code: chatId,

package/lib/helpers/filesHelper.js

@@ -21,7 +21,7 @@ async function convertPdfToImages(pdfName, existingPdfPath = null) {
 
   return new Promise((resolve, reject) => {
     const args = ['-jpeg', pdfPath, outputPattern];
-    logger.info('[convertPdfToImages] Running: pdftoppm', args.join(' '));
+    logger.info('[convertPdfToImages] Running: pdftoppm', { args: args.join(' ') });
     
     const timeout = 30000;
     let timedOut = false;

package/lib/helpers/threadHelper.js

@@ -1,12 +1,7 @@
 const { Thread } = require('../models/threadModel.js');
 const { createProvider } = require('../providers/createProvider.js');
 const llmConfig = require('../config/llmConfig.js');
-
-const log = (level, context, data, error = null) => {
-  const safeData = { ...data };
-  if (safeData.code) safeData.code = `${safeData.code.substring(0, 3)}***${safeData.code.slice(-4)}`;
-  console[level](`[${context}]`, error ? { error: error?.message || String(error), ...safeData } : safeData);
-};
+const { logger } = require('../utils/logger');
 
 const TERMINAL_STATUSES = ['cancelled', 'expired', 'completed', 'failed', 'incomplete'];
 const MAX_ATTEMPTS = 30;
@@ -15,7 +10,7 @@ const MAX_WAIT_MS = 30000;
 const getThread = async (code, message = null) => {
   try {
     let thread = await Thread.findOne({ code: code });
-    log('log', 'getThread', { code, hasThread: !!thread, hasRunId: !!(thread?.run_id) });
+    logger.info('[getThread]', { code: code, hasThread: !!thread, hasRunId: !!(thread?.run_id) });
 
     if (!thread && message) {
       thread = new Thread({ code, active: true });
@@ -32,18 +27,18 @@ const getThread = async (code, message = null) => {
           const run = await provider.getRun({ threadId: thread.getConversationId(), runId: thread.run_id });
           
           if (TERMINAL_STATUSES.includes(run.status)) {
-            log('log', 'getThread_terminal', { code, status: run.status, attempts });
+            logger.info('[getThread_terminal]', { code: code, status: run.status, attempts });
             break;
           }
         } catch (error) {
-          log('error', 'getThread_getRun_failed', { code, attempt: attempts }, error);
+          logger.error('[getThread_getRun_failed]', { code: code, attempt: attempts, error });
           break;
         }
         await new Promise(r => setTimeout(r, 1000));
       }
 
       if (attempts >= MAX_ATTEMPTS || (Date.now() - start) >= MAX_WAIT_MS) {
-        log('warn', 'getThread_timeout', { code, attempts, elapsed: Date.now() - start });
+        logger.warn('[getThread_timeout]', { code: code, attempts, elapsed: Date.now() - start });
       }
       
       await Thread.updateOne({ code, active: true }, { $set: { run_id: null } });
@@ -52,7 +47,7 @@ const getThread = async (code, message = null) => {
 
     return thread;
   } catch (error) {
-    log('error', 'getThread', { code }, error);
+    logger.error('[getThread]', { code: code, error });
     return null;
   }
 };
@@ -62,12 +57,48 @@ const getThreadInfo = async (code) => {
     let thread = await Thread.findOne({ code: code });
     return thread;
   } catch (error) {
-    log('error', 'getThreadInfo', { code }, error);
+    logger.error('[getThreadInfo]', { code: code, error });
+    return null;
+  }
+};
+
+const createPlaceholderThread = async (code) => {
+  try {
+    const existingThread = await Thread.findOne({ code });
+    if (existingThread) {
+      logger.info('[createPlaceholderThread_exists]', { code: code });
+      return existingThread;
+    }
+
+    const placeholderThread = new Thread({
+      code,
+      assistant_id: null,
+      conversation_id: null,
+      stopped: true
+    });
+
+    await placeholderThread.save();
+    logger.info('[createPlaceholderThread_created]', { code: code });
+    return placeholderThread;
+  } catch (error) {
+    logger.error('[createPlaceholderThread]', { code: code, error });
     return null;
   }
 };
 
+const ensureThreadExists = (code) => {
+  setImmediate(async () => {
+    try {
+      await createPlaceholderThread(code);
+    } catch (error) {
+      logger.error('[ensureThreadExists_background]', { code: code, error });
+    }
+  });
+};
+
 module.exports = {
   getThread,
-  getThreadInfo
+  getThreadInfo,
+  createPlaceholderThread,
+  ensureThreadExists
 };

package/lib/helpers/twilioHelper.js

@@ -26,22 +26,46 @@ function convertTwilioToInternalFormat(twilioMessage) {
 
 async function downloadMediaFromTwilio(mediaUrl, logger) {
   try {
-    logger.info(`Downloading media from: ${mediaUrl}`);
+    const authHeader = `Basic ${Buffer.from(
+      `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+    ).toString('base64')}`;
+
+    logger.info('[TwilioMedia] Starting download', {
+      url: mediaUrl,
+      hasAccountSid: !!process.env.TWILIO_ACCOUNT_SID,
+      hasAuthToken: !!process.env.TWILIO_AUTH_TOKEN,
+      accountSidLength: process.env.TWILIO_ACCOUNT_SID?.length || 0,
+      authHeaderSample: authHeader.substring(0, 20) + '...'
+    });
         
     const response = await axios({
       method: 'GET',
       url: mediaUrl,
       responseType: 'arraybuffer',
+      timeout: 30000,
       headers: {
-        'Authorization': `Basic ${Buffer.from(
-          `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
-        ).toString('base64')}`
+        'Authorization': authHeader
       }
     });
-        
+
+    logger.info('[TwilioMedia] Download successful', {
+      status: response.status,
+      contentType: response.headers['content-type'],
+      contentLength: response.headers['content-length'],
+      dataSize: response.data?.length || 0
+    });
+
     return Buffer.from(response.data);
   } catch (error) {
-    logger.error(`Failed to download media: ${error.message}`);
+    logger.error('[TwilioMedia] Download failed', {
+      message: error.message,
+      status: error.response?.status,
+      statusText: error.response?.statusText,
+      responseHeaders: error.response?.headers,
+      responseData: error.response?.data ? error.response.data.toString().substring(0, 500) : null,
+      url: mediaUrl,
+      hasCredentials: !!(process.env.TWILIO_ACCOUNT_SID && process.env.TWILIO_AUTH_TOKEN)
+    });
     throw error;
   }
 }

package/lib/index.js

@@ -39,7 +39,7 @@ class Nexus {
     try {
       setDefaultInstance(this.messaging);
     } catch (err) {
-      logger.warn('[Nexus] Failed to set default messaging instance:', err?.message || err);
+      logger.warn('[Nexus] Failed to set default messaging instance', { error: err?.message || err });
     }
     this.storage = null;
     this.messageParser = null;
@@ -147,7 +147,7 @@ class Nexus {
           llmConfigModule.setOpenAIClient(providerInstance.getClient());
         }
       } catch (err) {
-        logger.warn('[Nexus] Failed to expose OpenAI provider:', err?.message || err);
+        logger.warn('[Nexus] Failed to expose OpenAI provider', { error: err?.message || err });
       }
     }
 

package/lib/models/threadModel.js

@@ -2,15 +2,16 @@ const mongoose = require('mongoose');
 
 const threadSchema = new mongoose.Schema({
   code: { type: String, required: true },
-  assistant_id: { type: String, required: true },
-  conversation_id: { type: String, required: true },
+  assistant_id: { type: String, default: null },
+  conversation_id: { type: String, default: null },
   prompt_id: { type: String, default: null },
-  thread_id: { type: String, required: true },
+  thread_id: { type: String, default: null },
   patient_id: { type: String, default: null },
   run_id: { type: String, default: null },
   nombre: { type: String, default: null },
   active: { type: Boolean, default: true },
   stopped: { type: Boolean, default: false },
+  review: { type: Boolean, default: false },
   nextSid: { type: [String], default: [] }
 }, { timestamps: true });
 

package/lib/providers/OpenAIAssistantsProvider.js

@@ -282,7 +282,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) {
-        logger.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' })
@@ -331,7 +331,7 @@ class OpenAIAssistantsProvider {
       
       return this.checkRunStatus(assistant, threadId, runId, attempt + 1, maxRetries);
     } catch (error) {
-      logger.error('Error checking run status:', error);
+      logger.error('Error checking run status', { error });
       return { run: null, completed: false };
     }
   }

package/lib/providers/OpenAIResponsesProvider.js

@@ -258,7 +258,7 @@ class OpenAIResponsesProvider {
     topP,
     temperature,
     maxOutputTokens,
-    truncationStrategy,
+    truncationStrategy = 'auto',
     tools = [],
     model,
     assistant,
@@ -287,7 +287,7 @@ class OpenAIResponsesProvider {
           instructions: additionalInstructions || instructions,
           input: inputData,
           metadata, top_p: topP, temperature, max_output_tokens: maxOutputTokens,
-          truncation_strategy: truncationStrategy,
+          truncation: truncationStrategy,
           tools: transformToolsForResponsesAPIUtil(this.variant, tools),
         }), { providerName: PROVIDER_NAME });
 

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -11,7 +11,7 @@ async function executeFunctionCall(assistant, call, metadata = {}) {
   } catch (error) {
     result = { error: error?.message || 'Tool execution failed' };
     success = false;
-    logger.error('[OpenAIResponsesProvider] Tool execution failed', error);
+    logger.error('[OpenAIResponsesProvider] Tool execution failed', { error });
   }
   
   const toolData = {

package/lib/routes/index.js

@@ -66,6 +66,12 @@ const templateRouteDefinitions = {
   'DELETE /:id': 'deleteTemplate'
 };
 
+const threadRouteDefinitions = {
+  'PUT /review/:code': 'updateThreadReviewStatus',
+  'PUT /review/all': 'updateAllThreadsReviewStatus',
+  'GET /review': 'getThreadsByReviewStatus'
+};
+
 // Helper function to create Express router from route definitions
 const createRouter = (routeDefinitions, controllers) => {
   const router = express.Router();
@@ -93,6 +99,7 @@ const patientController = require('../controllers/patientController');
 const qualityMessageController = require('../controllers/qualityMessageController');
 const templateController = require('../controllers/templateController');
 const templateFlowController = require('../controllers/templateFlowController');
+const threadController = require('../controllers/threadController');
 const uploadController = require('../controllers/uploadController');
 
 // Built-in controllers mapping
@@ -152,7 +159,12 @@ const builtInControllers = {
   deleteFlow: templateFlowController.deleteFlow,
   submitForApproval: templateController.submitForApproval,
   checkApprovalStatus: templateController.checkApprovalStatus,
-  deleteTemplate: templateController.deleteTemplate
+  deleteTemplate: templateController.deleteTemplate,
+  
+  // Thread controllers
+  updateThreadReviewStatus: threadController.updateThreadReviewStatus,
+  updateAllThreadsReviewStatus: threadController.updateAllThreadsReviewStatus,
+  getThreadsByReviewStatus: threadController.getThreadsByReviewStatus
 };
 
 // Helper function to setup all default routes using built-in controllers
@@ -164,6 +176,7 @@ const setupDefaultRoutes = (app) => {
   app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
   app.use('/api/patient', createRouter(patientRouteDefinitions, builtInControllers));
   app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
+  app.use('/api/thread', createRouter(threadRouteDefinitions, builtInControllers));
 };
 
 module.exports = {
@@ -175,6 +188,7 @@ module.exports = {
   messageRoutes: messageRouteDefinitions,
   patientRoutes: patientRouteDefinitions,
   templateRoutes: templateRouteDefinitions,
+  threadRoutes: threadRouteDefinitions,
   
   // Helper functions
   createRouter,

package/lib/services/airtableService.js

@@ -10,7 +10,7 @@ async function addRecord(baseID, tableName, fields) {
     logger.info('Record added at', { tableName });
     return record;
   } catch (error) {
-    logger.error('Error adding record:', error);
+    logger.error('Error adding record', { error });
     throw error; 
   }
 }
@@ -31,7 +31,7 @@ async function getRecords(baseID, tableName) {
     });
     return records;
   } catch (error) {
-    logger.error('Error fetching records:', error);
+    logger.error('Error fetching records', { error });
   }
 }
 
@@ -105,7 +105,7 @@ async function addLinkedRecord(baseID, targetTable, fields, linkConfig) {
     const record = await addRecord(baseID, targetTable, [{ fields }]);
     return record;
   } catch (error) {
-    console.error('[addLinkedRecord] Error adding linked record:', error);
+    logger.error('[addLinkedRecord] Error adding linked record', { error });
     throw error;
   }
 }

package/lib/services/assistantServiceCore.js

@@ -17,7 +17,7 @@ const { logger } = require('../utils/logger');
 
 const createAssistantCore = async (code, assistant_id, messages = [], force = false) => {
   const findThread = await Thread.findOne({ code: code });
-  logger.info('[createAssistantCore] findThread', findThread);
+  logger.info('[createAssistantCore] findThread', { findThread });
   
   if (findThread && findThread.getConversationId() && !force) {
     logger.info('[createAssistantCore] Thread already exists');
@@ -34,7 +34,7 @@ const createAssistantCore = async (code, assistant_id, messages = [], force = fa
   }
   
   const curRow = await getCurRow(Historial_Clinico_ID, code);
-  logger.info('[createAssistantCore] curRow', curRow[0]);
+  logger.info('[createAssistantCore] curRow', { curRow: curRow[0] });
   const nombre = curRow?.[0]?.['name'] || null;
   const patientId = curRow?.[0]?.['record_id'] || null;
 
@@ -63,7 +63,7 @@ const createAssistantCore = async (code, assistant_id, messages = [], force = fa
     const condition = { $or: [{ code: code }] };
     const options = { new: true, upsert: true };
     const updatedThread = await Thread.findOneAndUpdate(condition, { run_id: null, ...thread }, options);
-    logger.info('[createAssistantCore] Updated thread:', updatedThread);
+    logger.info('[createAssistantCore] Updated thread', { updatedThread });
 
     return { success: true, assistant_id, thread: updatedThread };
   } catch (error) {
@@ -72,7 +72,7 @@ const createAssistantCore = async (code, assistant_id, messages = [], force = fa
   }
 };
 
-const addMsgAssistantCore = async (code, inMessages, role = 'user', reply = false, skipSystemMessage = false) => {
+const addMsgAssistantCore = async (code, inMessages, role = 'system', reply = false, skipSystemMessage = false) => {
   const thread = await getThread(code);
   if (!thread) return null;
 
@@ -105,7 +105,7 @@ const addMsgAssistantCore = async (code, inMessages, role = 'user', reply = fals
             raw: { role: role }
           });
         } catch (err) {
-          logger.error('[addMsgAssistantCore] Error saving system message:', err);
+          logger.error('[addMsgAssistantCore] Error saving system message', { err });
         }
       }
     }
@@ -121,7 +121,7 @@ const addMsgAssistantCore = async (code, inMessages, role = 'user', reply = fals
   }
 };
 
-const addInstructionCore = async (code, instruction, role = 'user') => {
+const addInstructionCore = async (code, instruction, role = 'system') => {
   const thread = await getThread(code);
   if (!thread) return null;
 
@@ -149,7 +149,7 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
         raw: { role: role }
       });
     } catch (err) {
-      logger.error('[addInstructionCore] Error saving instruction message:', err);
+      logger.error('[addInstructionCore] Error saving instruction message', { err });
     }
 
     logger.info('[addInstructionCore] Run response', { output: runResult?.output });

package/lib/services/conversationService.js

@@ -89,7 +89,7 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
         }
         return createConversation(conv, index);
       } catch (error) {
-        logger.error(`Error processing conversation ${index}:`, error);
+        logger.error(`Error processing conversation ${index}`, { error });
         return createConversation(conv, index, { name: 'Error Processing', lastMessage: 'Error processing conversation' });
       }
     });
@@ -97,7 +97,7 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
     logger.info(`Processed ${processedConversations.length} conversations`);
     return processedConversations;
   } catch (error) {
-    logger.error('Error in conversation mapping:', error);
+    logger.error('Error in conversation mapping', { error });
     return [];
   }
 };

package/lib/services/preprocessingHooks.js

@@ -18,7 +18,7 @@ const invokePreprocessingHandler = async (payload) => {
     const result = await preprocessingHandler(payload);
     return Boolean(result);
   } catch (error) {
-    logger.warn('[PreprocessingHooks] Handler threw an error:', error?.message || error);
+    logger.warn('[PreprocessingHooks] Handler threw an error', { error: error?.message || error });
     return false;
   }
 };

package/lib/storage/MongoStorage.js

@@ -52,7 +52,7 @@ class MongoStorage {
       logger.info('[MongoStorage] Message stored');
       return values;
     } catch (error) {
-      logger.error('Error saving message:', error);
+      logger.error('Error saving message', { error });
       throw error;
     }
   }
@@ -107,7 +107,7 @@ class MongoStorage {
         caption: primary.caption || messageData.caption
       };
     } catch (error) {
-      logger.error('[MongoStorage] Failed to enrich Twilio media message:', error);
+      logger.error('[MongoStorage] Failed to enrich Twilio media message', { error });
       return messageData;
     }
   }
@@ -168,7 +168,7 @@ class MongoStorage {
         .sort({ createdAt: -1 })
         .limit(limit);
     } catch (error) {
-      logger.error('Error getting messages:', error);
+      logger.error('Error getting messages', { error });
       throw error;
     }
   }
@@ -177,7 +177,7 @@ class MongoStorage {
     try {
       return await this.schemas.Thread.findOne({ code, active: true });
     } catch (error) {
-      logger.error('Error getting thread:', error);
+      logger.error('Error getting thread', { error });
       throw error;
     }
   }
@@ -188,7 +188,7 @@ class MongoStorage {
       await thread.save();
       return thread;
     } catch (error) {
-      logger.error('Error creating thread:', error);
+      logger.error('Error creating thread', { error });
       throw error;
     }
   }
@@ -201,7 +201,7 @@ class MongoStorage {
         { new: true }
       );
     } catch (error) {
-      logger.error('Error updating thread:', error);
+      logger.error('Error updating thread', { error });
       throw error;
     }
   }

package/lib/utils/errorHandler.js

@@ -1,7 +1,7 @@
 const { logger } = require('../utils/logger');
 
 const handleApiError = (res, error, message) => {
-  logger.error(message, error);
+  logger.error(message, { error });
   return res.status(500).json({ success: false, error: message });
 };
 

package/package.json

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