@peopl-health/nexus 4.3.3 → 4.4.0

package/lib/adapters/TwilioProvider.js

@@ -10,6 +10,7 @@ const { sanitizeMediaFilename } = require('../utils/sanitizerUtils');
 const { validateMedia, getMediaType, MEDIA_LIMITS, STICKER_DIMENSIONS } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
 const { calculateDelay } = require('../utils/scheduleUtils');
+const { isBenchMode } = require('../utils/benchModeHelper');
 
 const { ScheduledMessage } = require('../models/agendaMessageModel');
 
@@ -49,6 +50,24 @@ class TwilioProvider extends MessageProvider {
       throw new Error('Twilio provider not initialized');
     }
 
+    if (isBenchMode(messageData?.code)) {
+      const benchSid = `bench_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      logger.info('[TwilioProvider] bench.suppressed_send', {
+        event: 'bench.suppressed_send',
+        code: messageData.code,
+        body: messageData.body || null,
+        contentSid: messageData.contentSid || null
+      });
+      return {
+        success: true,
+        messageId: benchSid,
+        provider: 'twilio',
+        status: 'bench_suppressed',
+        result: { sid: benchSid, status: 'bench_suppressed' },
+        finalize: { sid: benchSid, status: 'bench_suppressed' }
+      };
+    }
+
     const { code, body, fileUrl, fileType, variables, contentSid } = messageData;
 
     const formattedFrom = ensureWhatsAppFormat(this.whatsappNumber);
@@ -236,7 +255,8 @@ class TwilioProvider extends MessageProvider {
         });
         const response = await sender(payload);
         const messageId = response?.result?.sid || null;
-        await updateStatus('sent', messageId);
+        const persistedStatus = response?.status === 'bench_suppressed' ? 'bench_suppressed' : 'sent';
+        await updateStatus(persistedStatus, messageId);
       } catch (error) {
         await updateStatus('failed', null, error);
         logger.error(`Scheduled message failed: ${error.message}`);

package/lib/controllers/conversationController.js

@@ -441,7 +441,7 @@ const markMessagesAsReadController = async (req, res) => {
       .catch(err => logger.error('[markMessagesAsRead] Failed to reset thread unreadCount', { phoneNumber, error: err.message }));
 
     if (modifiedCount > 0) {
-      updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${phoneNumber}"`, { read: true })
+      updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${phoneNumber}"`, { read: true }, phoneNumber)
         .catch(err => logger.error('[markMessagesAsRead] Failed to update message_monitor', { phoneNumber, error: err.message }));
     }
 

package/lib/controllers/prescriptionController.js

@@ -29,7 +29,8 @@ const createPrescriptionController = async (req, res) => {
         referenceTable: 'estado_general',
         referenceFilter: `{whatsapp_id}='${whatsappId}'`,
         linkFieldName: 'patient_id'
-      }
+      },
+      whatsappId
     );
 
     logger.info('[PrescriptionController] Prescription created', { code: whatsappId });

package/lib/helpers/messageStatusHelper.js

@@ -61,14 +61,16 @@ async function updateMessageStatus(messageSid, status, errorCode = null, errorMe
             referenceTable: 'message_monitor',
             referenceFilter: `{whatsapp_id}="${updated.numero}"`,
             linkFieldName: 'message_monitor'
-          }
+          },
+          updated.numero
         ).catch(err => logger.error('[MessageStatus] Failed to create undelivered_messages record', { messageSid, error: err.message }));
       } else {
         updateRecordByFilter(
           Monitoreo_ID,
           'undelivered_messages',
           `{message_id}="${updated.message_id}"`,
-          { status }
+          { status },
+          updated.numero
         ).catch(err => logger.error('[MessageStatus] Failed to update undelivered_messages record', { messageSid, error: err.message }));
       }
     }

package/lib/helpers/threadHelper.js

@@ -36,7 +36,7 @@ const getThreadInfo = async (code) => {
 const switchThreadStoppedStatus = async (code, stopped) => {
   await Thread.updateOne({ code }, { active: true, stopped });
 
-  updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${code}"`, { stopped })
+  updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${code}"`, { stopped }, code)
     .catch(err => logger.error('[switchThreadStoppedStatus] Failed to update message_monitor', { code, error: err.message }));
 };
 
@@ -45,7 +45,7 @@ const setThreadPromptId = async (code, promptId) => {
   Thread.setAssistantId(updateFields, promptId);
   await Thread.updateOne({ code: code }, { $set: updateFields });
 
-  updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${code}"`, { prompt_id: promptId })
+  updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${code}"`, { prompt_id: promptId }, code)
     .catch(err => logger.error('[setThreadPromptId] Failed to update message_monitor', { code, error: err.message }));
 };
 

package/lib/helpers/twilioMediaHelper.js

@@ -31,7 +31,7 @@ async function uploadMediaToAirtable(whatsappId, mediaUrl, baseID, tableName) {
       referenceTable: 'estado_general',
       referenceFilter: `whatsapp_id = "${whatsappId}"`,
       linkFieldName: 'patient_id'
-    });
+    }, whatsappId);
   } catch (error) {
     logger.warn('[uploadMediaToAirtable] Failed', { whatsappId, error: error.message });
     throw error;

package/lib/memory/MemoryExtractor.js

@@ -2,6 +2,7 @@ const { OpenAI } = require('openai');
 
 const { logger } = require('../utils/logger');
 const { retryWithBackoff } = require('../utils/retryUtils');
+const { isBenchMode } = require('../utils/benchModeHelper');
 
 const { getPatientMemory } = require('../models/patientMemoryModel');
 const { getConversationSummary } = require('../models/conversationSummaryModel');
@@ -69,6 +70,10 @@ class MemoryExtractor {
   }
 
   async processSessionEnd(numero, sessionMessages, sessionId) {
+    if (isBenchMode(numero)) {
+      logger.info('[MemoryExtractor] bench.suppressed_extraction', { event: 'bench.suppressed_extraction', numero, sessionId });
+      return { summary: null, memoriesCreated: 0, memoriesReinforced: 0 };
+    }
     if (!sessionMessages?.length) {
       logger.info('[MemoryExtractor] No messages to process', { numero, sessionId });
       return { summary: null, memoriesCreated: 0, memoriesReinforced: 0 };

package/lib/memory/SessionManager.js

@@ -1,4 +1,5 @@
 const { logger } = require('../utils/logger');
+const { isBenchMode } = require('../utils/benchModeHelper');
 
 const { Message } = require('../models/messageModel');
 
@@ -13,6 +14,7 @@ class SessionManager {
   }
 
   recordActivity(numero) {
+    if (isBenchMode(numero)) return;
     const now = Date.now();
     const existing = this.activeSessions.get(numero);
 
@@ -58,6 +60,7 @@ class SessionManager {
   }
 
   async processSessionEndForNumero(numero) {
+    if (isBenchMode(numero)) return null;
     const session = this.activeSessions.get(numero);
     const sessionId = session?.sessionId || this._generateSessionId(numero);
     const sessionStart = session?.sessionStart || Date.now() - this.idleTimeoutMs;

package/lib/models/messageModel.js

@@ -169,7 +169,7 @@ async function insertMessage(values) {
     updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${values.numero}"`, {
       ...(values.from_me ? { last_message_bot: values.body } : { last_message_patient: values.body, read: false }),
       ...(values.from_me ? { last_message_bot_time: values.timestamp } : { last_message_patient_time: values.timestamp })
-    }).catch(err => logger.error('[MongoStorage] Failed to update message_monitor table', { numero: values.numero, error: err.message }));
+    }, values.numero).catch(err => logger.error('[MongoStorage] Failed to update message_monitor table', { numero: values.numero, error: err.message }));
 
     logger.info('[MongoStorage] Message inserted or updated successfully');
     return { isNew, doc };

package/lib/observability/index.js

@@ -1,5 +1,6 @@
 const { trace, metrics } = require('@opentelemetry/api');
 
+const { hasBenchAttribute } = require('../utils/benchModeHelper');
 const { initTelemetry, shutdownTelemetry } = require('../observability/telemetry');
 
 const tracer = trace.getTracer('nexus-assistant');
@@ -51,33 +52,39 @@ const s3UploadDuration = meter.createHistogram('nexus_s3_upload_duration', {
 });
 
 async function traceOperation(name, operation, attributes = {}) {
-  const span = tracer.startSpan(name, { attributes });
+  const isBench = hasBenchAttribute(attributes);
+  const spanAttributes = isBench ? { ...attributes, bench: true } : attributes;
+  const span = tracer.startSpan(name, { attributes: spanAttributes });
   const startTime = Date.now();
-  
+
   try {
-    activeOperationsGauge.add(1, attributes);
-    
+    if (!isBench) activeOperationsGauge.add(1, attributes);
+
     const result = await operation(span);
-    
+
     const duration = Date.now() - startTime;
-    
-    responseTimeHistogram.record(duration, attributes);
-    operationCounter.add(1, { ...attributes, success: true });
-    
+
+    if (!isBench) {
+      responseTimeHistogram.record(duration, attributes);
+      operationCounter.add(1, { ...attributes, success: true });
+    }
+
     span.setAttributes({
       'operation.duration_ms': duration,
       'operation.success': true,
     });
-    
+
     span.setStatus({ code: 1 });
     return result;
-    
+
   } catch (error) {
     const duration = Date.now() - startTime;
-    
-    operationCounter.add(1, { ...attributes, success: false });
-    responseTimeHistogram.record(duration, { ...attributes, error: true });
-    
+
+    if (!isBench) {
+      operationCounter.add(1, { ...attributes, success: false });
+      responseTimeHistogram.record(duration, { ...attributes, error: true });
+    }
+
     span.recordException(error);
     span.setStatus({ code: 2, message: error.message });
     span.setAttributes({
@@ -85,16 +92,18 @@ async function traceOperation(name, operation, attributes = {}) {
       'operation.success': false,
       'error.message': error.message,
     });
-    
+
     throw error;
   } finally {
-    activeOperationsGauge.add(-1, attributes);
+    if (!isBench) activeOperationsGauge.add(-1, attributes);
     span.end();
   }
 }
 
 function createSpan(name, attributes = {}) {
-  return tracer.startSpan(name, { attributes });
+  const isBench = hasBenchAttribute(attributes);
+  const spanAttributes = isBench ? { ...attributes, bench: true } : attributes;
+  return tracer.startSpan(name, { attributes: spanAttributes });
 }
 
 function init(config = {}) {
@@ -103,46 +112,51 @@ function init(config = {}) {
 }
 
 function traceAssistantReply(operation, attributes = {}) {
+  const isBench = hasBenchAttribute(attributes);
   return traceOperation('assistant_reply', async (span) => {
     const startTime = Date.now();
     try {
       const result = await operation(span);
       const duration = Date.now() - startTime;
-      assistantReplyDuration.record(duration, attributes);
+      if (!isBench) assistantReplyDuration.record(duration, attributes);
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      assistantReplyDuration.record(duration, { ...attributes, error: true });
+      if (!isBench) assistantReplyDuration.record(duration, { ...attributes, error: true });
       throw error;
     }
   }, attributes);
 }
 
 function traceAssistantInstruction(operation, attributes = {}) {
+  const isBench = hasBenchAttribute(attributes);
   return traceOperation('assistant_instruction', async (span) => {
     const startTime = Date.now();
     try {
       const result = await operation(span);
       const duration = Date.now() - startTime;
-      assistantInstructionDuration.record(duration, attributes);
+      if (!isBench) assistantInstructionDuration.record(duration, attributes);
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      assistantInstructionDuration.record(duration, { ...attributes, error: true });
+      if (!isBench) assistantInstructionDuration.record(duration, { ...attributes, error: true });
       throw error;
     }
   }, attributes);
 }
 
 function recordAssistantRetry(attributes = {}) {
+  if (hasBenchAttribute(attributes)) return;
   assistantRetryCounter.add(1, attributes);
 }
 
 function recordThreadOperation(operationType, attributes = {}) {
+  if (hasBenchAttribute(attributes)) return;
   threadOperationsCounter.add(1, { ...attributes, operation_type: operationType });
 }
 
 function recordFileOperation(operationType, attributes = {}) {
+  if (hasBenchAttribute(attributes)) return;
   fileOperationsCounter.add(1, { ...attributes, operation_type: operationType });
 }
 

package/lib/services/airtableService.js

@@ -1,6 +1,7 @@
 const { airtable } = require('../config/airtableConfig');
 
 const { logger } = require('../utils/logger');
+const { isBenchMode } = require('../utils/benchModeHelper');
 
 let evalMode = false;
 
@@ -23,7 +24,11 @@ async function collectRecords(query, mapper = r => r.fields) {
   return records;
 }
 
-async function addRecord(baseID, tableName, fields) {
+async function addRecord(baseID, tableName, fields, context = null) {
+  if (isBenchMode(context)) {
+    logger.info('[addRecord:bench] Suppressed', { tableName, code: context });
+    return { id: 'bench_mock_record', fields: Array.isArray(fields) ? fields[0]?.fields || {} : fields };
+  }
   if (evalMode) {
     logger.info('[addRecord:eval] Muted', { tableName });
     return { id: 'eval_mock_record', fields: Array.isArray(fields) ? fields[0]?.fields || {} : fields };
@@ -60,7 +65,11 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view',
   }
 }
 
-async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
+async function updateRecordByFilter(baseID, tableName, filter, updateFields, context = null) {
+  if (isBenchMode(context)) {
+    logger.info('[updateRecordByFilter:bench] Suppressed', { tableName, filter, code: context });
+    return [{ id: 'bench_mock_record', fields: updateFields }];
+  }
   if (evalMode) {
     logger.info('[updateRecordByFilter:eval] Muted', { tableName, filter });
     return [{ id: 'eval_mock_record', fields: updateFields }];
@@ -85,9 +94,14 @@ async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
   }
 }
 
-async function addLinkedRecord(baseID, targetTable, fields, linkConfig) {
+async function addLinkedRecord(baseID, targetTable, fields, linkConfig, context = null) {
   if (!baseID) throw new Error('[addLinkedRecord] Base ID is required');
 
+  if (isBenchMode(context)) {
+    logger.info('[addLinkedRecord:bench] Suppressed', { targetTable, code: context });
+    return { id: 'bench_mock_record', fields };
+  }
+
   try {
     if (linkConfig) {
       const { referenceTable, referenceFilter, linkFieldName } = linkConfig;

package/lib/services/patientService.js

@@ -55,13 +55,13 @@ const updatePatientInformation = async (code, fields, auditContext = {}) => {
       .map(([key, value]) => [key.replace(/^updt_/, ''), value])
   );
 
-  const result = await updateRecordByFilter(Estado_General_ID, 'estado_general', filter, fields);
+  const result = await updateRecordByFilter(Estado_General_ID, 'estado_general', filter, fields, code);
 
   let failedFields = [];
   if (!result) {
     logger.warn('[updatePatientInformation] Bulk update failed, retrying fields individually', { code });
     for (const [key, value] of Object.entries(fields)) {
-      const fieldResult = await updateRecordByFilter(Estado_General_ID, 'estado_general', filter, { [key]: value });
+      const fieldResult = await updateRecordByFilter(Estado_General_ID, 'estado_general', filter, { [key]: value }, code);
       if (!fieldResult) {
         failedFields.push({ key, value });
         const cleanKey = key.replace(/^updt_/, '');

package/lib/utils/benchModeHelper.js

@@ -0,0 +1,31 @@
+const BENCH_CODE_PREFIX = 'bench:';
+
+function extractCode(codeOrThread) {
+  if (!codeOrThread) return null;
+  if (typeof codeOrThread === 'string') return codeOrThread;
+  if (typeof codeOrThread === 'object') {
+    return codeOrThread.code || codeOrThread.numero || codeOrThread.thread_code || null;
+  }
+  return null;
+}
+
+function isBenchMode(codeOrThread) {
+  const code = extractCode(codeOrThread);
+  return typeof code === 'string' && code.startsWith(BENCH_CODE_PREFIX);
+}
+
+function hasBenchAttribute(attributes) {
+  if (!attributes || typeof attributes !== 'object') return false;
+  if (attributes.bench === true) return true;
+  for (const key of Object.keys(attributes)) {
+    const value = attributes[key];
+    if (typeof value === 'string' && value.startsWith(BENCH_CODE_PREFIX)) return true;
+  }
+  return false;
+}
+
+module.exports = {
+  BENCH_CODE_PREFIX,
+  isBenchMode,
+  hasBenchAttribute
+};

package/lib/utils/tracingDecorator.js

@@ -1,6 +1,7 @@
 const { SpanStatusCode } = require('@opentelemetry/api');
 
 const { createSpan } = require('../observability');
+const { hasBenchAttribute } = require('./benchModeHelper');
 
 const withTracing = (fn, spanName, attributeMapper = null, options = {}) => {
   return async function (...args) {
@@ -9,7 +10,11 @@ const withTracing = (fn, spanName, attributeMapper = null, options = {}) => {
 
     try {
       if (typeof attributeMapper === 'function') {
-        span.setAttributes(attributeMapper(...args));
+        const attributes = attributeMapper(...args);
+        span.setAttributes(attributes);
+        if (hasBenchAttribute(attributes)) {
+          span.setAttribute('bench', true);
+        }
       }
       const result = await fn.apply(this, args);
       span.setStatus({ code: SpanStatusCode.OK });

package/package.json

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