@peopl-health/nexus 3.3.18 → 3.4.0-fix-version

package/lib/eval/EvalProvider.js

@@ -0,0 +1,309 @@
+const { OpenAI } = require('openai');
+
+const { Config_ID } = require('../config/airtableConfig');
+const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
+const { retryWithBackoff } = require('../utils/retryUtils');
+const { logger } = require('../utils/logger');
+const { Thread } = require('../models/threadModel');
+const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
+const { OpenAIResponsesProvider } = require('../providers/OpenAIResponsesProvider');
+const { handleFunctionCalls } = require('../providers/OpenAIResponsesProviderTools');
+const { getRecordByFilter } = require('../services/airtableService');
+const { getAssistantById } = require('../services/assistantResolver');
+
+const MAX_FUNCTION_ROUNDS = parseInt(process.env.MAX_FUNCTION_ROUNDS || '5', 10);
+
+/**
+ * Promptfoo-compatible eval provider that wraps the real Nexus pipeline.
+ *
+ * Modes:
+ *  - 'context-only':   Builds context, calls LLM, no tool schemas sent.
+ *  - 'dry-run':        Sends tool schemas so LLM can decide to call tools,
+ *                       but captures calls without executing them. (default)
+ *  - 'full-pipeline':  Executes tools for real. Use only with safe/mocked tools.
+ */
+class EvalProvider {
+  constructor(options = {}) {
+    const config = options.config || {};
+    this.model = config.model || process.env.OPENAI_MODEL || 'gpt-5';
+    this.temperature = config.temperature ?? 0.7;
+    this.maxOutputTokens = config.maxOutputTokens ?? 400;
+    this.assistantId = config.assistantId || null;
+    this.mode = config.mode || 'dry-run';
+    this.promptSource = config.promptSource || null;
+    // tool_choice: 'auto' (default, matches production), 'required', 'none',
+    // or { type: 'function', name: 'toolName' } to force a specific tool
+    this.toolChoice = config.toolChoice || 'auto';
+    this.promptVersions = config.promptVersions || {};
+    this.label = options.label || `nexus:${this.model}`;
+
+    this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    this.memoryManager = new DefaultMemoryManager();
+    this.provider = new OpenAIResponsesProvider({
+      client: this.client,
+      defaultModels: { responseModel: this.model },
+    });
+  }
+
+  id() {
+    return this.label;
+  }
+
+  async callApi(prompt, context) {
+    const vars = context.vars || {};
+    const numero = vars.numero;
+    if (!numero) return { error: 'Missing required var: numero' };
+
+    try {
+      const beforeCheckpoint = vars.beforeCheckpoint ? new Date(vars.beforeCheckpoint) : null;
+      let assistantId = vars.assistantId || this.assistantId;
+
+      const thread = await Thread.findOne({ code: numero });
+      if (!assistantId && thread) {
+        assistantId = thread.prompt_id || thread.assistant_id || null;
+      }
+
+      const { messages, promptVariables, lastUserMessage } = await this._buildContext(numero, beforeCheckpoint);
+
+      const { devContent, assistant, toolSchemas } = await this._resolvePrompt(prompt, assistantId, thread, promptVariables);
+
+      const apiConfig = this._buildApiConfig(devContent, messages, assistantId, promptVariables, toolSchemas);
+
+      const startTime = Date.now();
+      const { finalResponse, toolCallsRequested, allToolsExecuted, accumulatedUsage } =
+        await this._executeWithToolLoop(apiConfig, assistant);
+
+      return this._formatResult({
+        finalResponse, toolCallsRequested, allToolsExecuted,
+        accumulatedUsage, assistantId, numero, lastUserMessage,
+        messages, promptVariables, startTime,
+      });
+    } catch (error) {
+      logger.error('[NexusEvalProvider] callApi failed', { error: error.message, numero });
+      return { error: error.message };
+    }
+  }
+
+  async _buildContext(numero, beforeCheckpoint) {
+    const messages = await this.memoryManager.buildContext({
+      thread: { code: numero },
+      config: { beforeCheckpoint },
+    });
+
+    const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+    const lastUserMessage = (typeof lastUserMsg?.content === 'string'
+      ? lastUserMsg.content : ''
+    ).substring(0, 200);
+
+    const clinicalData = await this.memoryManager.getClinicalData(numero);
+    const promptVariables = {
+      clinical_context: clinicalData?.clinicalContext ?? '',
+      last_symptoms: clinicalData?.lastSymptoms ?? '',
+      current_date: getCurrentMexicoDateTime(),
+    };
+
+    return { messages, promptVariables, lastUserMessage };
+  }
+
+  async _resolvePrompt(fallbackPrompt, assistantId, thread, promptVariables) {
+    let devContent;
+    if (this.promptSource === 'airtable' && assistantId) {
+      const devRecord = await getRecordByFilter(Config_ID, 'responses', `{prompt_id} = "${assistantId}"`);
+      devContent = devRecord?.[0]?.content || '';
+    } else {
+      devContent = fallbackPrompt;
+    }
+    devContent = devContent.replace(/\{\{(\w+)\}\}/g, (_, key) => promptVariables[key] ?? '');
+
+    let assistant = null;
+    let toolSchemas = [];
+    if (this.mode !== 'context-only' && assistantId) {
+      try {
+        assistant = getAssistantById(assistantId, thread);
+        toolSchemas = assistant.getToolSchemas?.() || [];
+        if (assistant.tools?.size) {
+          const toolNames = Array.from(assistant.tools.keys()).join(', ');
+          devContent += `\n\nYou only have access to these tools: ${toolNames}. Do not call or reference any tools not listed here.`;
+        }
+      } catch {
+        logger.warn('[NexusEvalProvider] Failed to resolve assistant', { assistantId });
+      }
+    }
+
+    return { devContent, assistant, toolSchemas };
+  }
+
+  _buildApiConfig(devContent, messages, assistantId, promptVariables, toolSchemas) {
+    const convertedMessages = this.provider._convertItemsToApiFormat(messages);
+    const input = [{ role: 'developer', content: devContent }, ...convertedMessages];
+    const apiConfig = { input, instructions: '' };
+
+    if (assistantId) {
+      apiConfig.prompt = { id: assistantId, variables: promptVariables };
+      const version = this.promptVersions[assistantId];
+      if (version) apiConfig.prompt.version = String(version);
+    } else {
+      apiConfig.model = this.model;
+      apiConfig.temperature = this.temperature;
+      apiConfig.max_output_tokens = this.maxOutputTokens;
+    }
+
+    if (this.mode !== 'context-only') {
+      apiConfig.tool_choice = this.toolChoice;
+    }
+
+    if (toolSchemas.length > 0 && !assistantId) {
+      apiConfig.tools = toolSchemas.map(schema => {
+        if (schema.type === 'function' && schema.function) {
+          const { name, description, parameters, strict } = schema.function;
+          return { type: 'function', name, description, parameters, strict };
+        }
+        return schema;
+      });
+    }
+
+    return apiConfig;
+  }
+
+  async _executeWithToolLoop(apiConfig, assistant) {
+    const { result: response } = await retryWithBackoff(
+      () => this.client.responses.create(apiConfig),
+      { providerName: 'NexusEvalProvider' }
+    );
+
+    let finalResponse = response;
+    const toolCallsRequested = [];
+    const allToolsExecuted = [];
+    const accumulatedUsage = {
+      input_tokens: response.usage?.input_tokens || 0,
+      output_tokens: response.usage?.output_tokens || 0,
+      total_tokens: response.usage?.total_tokens || 0,
+    };
+
+    const functionCalls = (response.output || []).filter(item => item.type === 'function_call');
+    if (!functionCalls.length) {
+      return { finalResponse, toolCallsRequested, allToolsExecuted, accumulatedUsage };
+    }
+
+    // Record initial tool calls
+    for (const call of functionCalls) {
+      toolCallsRequested.push({
+        name: call.name,
+        arguments: call.arguments ? JSON.parse(call.arguments) : {},
+        call_id: call.call_id,
+      });
+    }
+
+    if (this.mode === 'full-pipeline' && assistant) {
+      finalResponse = await this._executeFullPipeline(
+        apiConfig, finalResponse, assistant, toolCallsRequested, allToolsExecuted, accumulatedUsage
+      );
+    } else if (this.mode === 'dry-run') {
+      finalResponse = await this._executeDryRun(apiConfig, finalResponse, functionCalls, accumulatedUsage);
+    }
+
+    return { finalResponse, toolCallsRequested, allToolsExecuted, accumulatedUsage };
+  }
+
+  async _executeFullPipeline(apiConfig, initialResponse, assistant, toolCallsRequested, allToolsExecuted, usage) {
+    let finalResponse = initialResponse;
+    let currentInput = [...apiConfig.input];
+
+    for (let round = 1; round <= MAX_FUNCTION_ROUNDS; round++) {
+      const calls = finalResponse.output.filter(item => item.type === 'function_call');
+      if (!calls.length) break;
+
+      const { outputs, toolsExecuted } = await handleFunctionCalls(calls, assistant);
+      currentInput.push(...finalResponse.output, ...outputs);
+      allToolsExecuted.push(...toolsExecuted);
+
+      for (const call of calls) {
+        if (!toolCallsRequested.find(t => t.call_id === call.call_id)) {
+          toolCallsRequested.push({
+            name: call.name,
+            arguments: call.arguments ? JSON.parse(call.arguments) : {},
+            call_id: call.call_id,
+          });
+        }
+      }
+
+      const { result: followUp } = await retryWithBackoff(
+        () => this.client.responses.create({ ...apiConfig, input: currentInput, tool_choice: 'auto' }),
+        { providerName: 'NexusEvalProvider' }
+      );
+      this._addUsage(usage, followUp.usage);
+      finalResponse = followUp;
+    }
+
+    return finalResponse;
+  }
+
+  async _executeDryRun(apiConfig, initialResponse, functionCalls, usage) {
+    const currentInput = [...apiConfig.input, ...initialResponse.output];
+    for (const call of functionCalls) {
+      currentInput.push({
+        type: 'function_call_output',
+        call_id: call.call_id,
+        output: JSON.stringify({ success: true }),
+      });
+    }
+
+    logger.info('[NexusEvalProvider] Dry-run: sending stub outputs', {
+      tools: functionCalls.map(c => c.name),
+    });
+
+    const { result: followUp } = await retryWithBackoff(
+      () => this.client.responses.create({ ...apiConfig, input: currentInput, tool_choice: 'auto' }),
+      { providerName: 'NexusEvalProvider' }
+    );
+    this._addUsage(usage, followUp.usage);
+    return followUp;
+  }
+
+  _addUsage(accumulated, newUsage) {
+    accumulated.input_tokens += newUsage?.input_tokens || 0;
+    accumulated.output_tokens += newUsage?.output_tokens || 0;
+    accumulated.total_tokens += newUsage?.total_tokens || 0;
+  }
+
+  _formatResult({ finalResponse, toolCallsRequested, allToolsExecuted, accumulatedUsage, assistantId, numero, lastUserMessage, messages, promptVariables, startTime }) {
+    const output = this.provider._extractMessageOutput(finalResponse);
+    const durationMs = Date.now() - startTime;
+    const toolNames = toolCallsRequested.map(t => t.name);
+
+    logger.info('[NexusEvalProvider] Result', {
+      assistantId, model: finalResponse.model || this.model,
+      lastUserMessage, toolCallsCaptured: toolNames,
+      outputLength: (output || '').length, durationMs,
+    });
+
+    const toolsHeader = toolNames.length ? `[tools: ${toolNames.join(', ')}]\n---\n` : '';
+
+    return {
+      output: `${toolsHeader}${output || ''}`,
+      tokenUsage: {
+        total: accumulatedUsage.total_tokens,
+        prompt: accumulatedUsage.input_tokens,
+        completion: accumulatedUsage.output_tokens,
+      },
+      metadata: {
+        model: finalResponse.model || this.model,
+        numero, assistantId, lastUserMessage,
+        mode: this.mode,
+        contextMessages: messages.length,
+        clinicalContext: promptVariables.clinical_context ? 'present' : 'absent',
+        durationMs,
+        toolCalls: toolCallsRequested,
+        toolsExecuted: allToolsExecuted.map(t => ({
+          name: t.tool_name,
+          arguments: t.tool_arguments,
+          output: t.tool_output,
+          success: t.success,
+          duration_ms: t.execution_time_ms,
+        })),
+      },
+    };
+  }
+}
+
+module.exports = { EvalProvider };

package/lib/helpers/assistantHelper.js

@@ -23,9 +23,10 @@ const runAssistantAndWait = async ({ thread, assistant, message = null, runConfi
   const provider = createLLMProvider({ variant: process.env.VARIANT || 'assistants' });
   const { polling, tools: configTools, ...config } = runConfig;
   const tools = assistant.getToolSchemas?.() || configTools || [];
+  const messageForRun = Array.isArray(message) && message.length > 0 ? message[0] : message;
 
   return withThreadRecovery(
-    (currentThread = thread) => provider.executeRun({ thread: currentThread, message, assistant, tools, config, polling }),
+    (currentThread = thread) => provider.executeRun({ thread: currentThread, message: messageForRun, assistant, tools, config, polling }),
     thread
   );
 };

package/lib/helpers/llmsHelper.js

@@ -37,7 +37,7 @@ async function analyzeImage(imagePath, isSticker = false, contentType = null) {
     const imageBuffer = await fs.promises.readFile(imagePath);
     const base64Image = imageBuffer.toString('base64');
 
-    const createImageMessage = (prompt, model = 'claude-3-7-sonnet-20250219') => anthropicClient.messages.create({
+    const createImageMessage = (prompt, model = 'claude-sonnet-4-5-20250929') => anthropicClient.messages.create({
       model, max_tokens: 1024,
       messages: [{ role: 'user', content: [
         { type: 'image', source: { type: 'base64', media_type: mimeType, data: base64Image } },

package/lib/helpers/messageHelper.js

@@ -99,6 +99,49 @@ function formatMessage(reply) {
   }
 }
 
+function getMessageTools(reply) {
+  const tools = reply?.tools_executed;
+  if (!tools?.length) return [];
+
+  const msgId = reply?.message_id ?? `msg_${Date.now()}`;
+  const items = [];
+
+  try {
+    // API requires function_call id to start with "fc" and function_call_output to reference it via call_id.
+    tools.forEach((t, i) => {
+      const safeId = `${msgId}_${i}`.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 80);
+      const functionCallId = `fc_${safeId}`;
+      const argsStr = JSON.stringify(t.tool_arguments ?? {});
+      let outputStr;
+      if (t.tool_output != null) {
+        outputStr = typeof t.tool_output === 'string'
+          ? t.tool_output
+          : JSON.stringify(t.tool_output);
+      } else {
+        outputStr = JSON.stringify({ success: t.success !== false });
+      }
+
+      items.push({
+        type: 'function_call',
+        id: functionCallId,
+        call_id: functionCallId,
+        name: t.tool_name,
+        arguments: argsStr
+      });
+      items.push({
+        type: 'function_call_output',
+        id: `fco_${safeId}`,
+        call_id: functionCallId,
+        output: outputStr
+      });
+    });
+    return items;
+  } catch (error) {
+    logger.error('[getMessageTools] Error', { messageId: reply?.message_id, error: error.message });
+    return [];
+  }
+}
+
 async function isRecentMessage(chatId) {
   const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
   const recent = await Message.findOne({
@@ -113,5 +156,6 @@ module.exports = {
   getLastMessages,
   getLastNMessages,
   formatMessage,
+  getMessageTools,
   isRecentMessage
 };

package/lib/index.js

@@ -10,7 +10,7 @@ const { OpenAIAssistantsProvider } = require('./providers/OpenAIAssistantsProvid
 const { OpenAIResponsesProvider } = require('./providers/OpenAIResponsesProvider');
 const runtimeConfig = require('./config/runtimeConfig');
 const llmConfigModule = require('./config/llmConfig');
-const { setModelDatabases, setModelDatabase, getModelDatabase } = require('./config/mongoConfig');
+const { setModelDatabases, setModelDatabase, getModelDatabase, connect: mongoConnect, disconnect: mongoDisconnect, getConnection: mongoGetConnection } = require('./config/mongoConfig');
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
 const { BaseAssistant } = require('./assistants/BaseAssistant');
@@ -219,6 +219,8 @@ class Nexus {
 
 const routes = require('./routes');
 const { resetAll } = require('./config/lifecycle');
+const { EvalProvider } = require('./eval/EvalProvider');
+const airtableService = require('./services/airtableService');
 
 module.exports = {
   Nexus,
@@ -254,5 +256,11 @@ module.exports = {
   createQueueAdapter,
   registerQueueAdapter,
 
-  resetAll
+  resetAll,
+
+  mongoConnect,
+  mongoDisconnect,
+  mongoGetConnection,
+  EvalProvider,
+  airtableService,
 };

package/lib/memory/DefaultMemoryManager.js

@@ -4,7 +4,7 @@ const { logger } = require('../utils/logger');
 
 const { MemoryManager } = require('../memory/MemoryManager');
 
-const { getLastNMessages, formatMessage } = require('../helpers/messageHelper');
+const { getLastNMessages, getMessageTools, formatMessage } = require('../helpers/messageHelper');
 
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
 
@@ -20,7 +20,7 @@ class DefaultMemoryManager extends MemoryManager {
     this._logActivity('Building context', { threadCode: thread.code });
 
     try {
-      const beforeCheckpoint = message ? message.createdAt : null;
+      const beforeCheckpoint = config.beforeCheckpoint ?? message?.createdAt ?? null;
       const allMessages = await getLastNMessages(thread.code, this.maxHistoricalMessages, beforeCheckpoint, {
         query: { origin: { $ne: 'instruction' } }
       });
@@ -32,12 +32,16 @@ class DefaultMemoryManager extends MemoryManager {
 
       const roleMap = { system: 'system', patient: 'user' };
       const context = allMessages.reverse().flatMap(msg => {
-        const formattedContents = formatMessage(msg);
-        return formattedContents.map(content => ({
-          role: roleMap[msg.origin] || 'assistant',
-          content: content || msg.body || msg.content || ''
-        }));
-      }).filter(msg => msg.content);
+        const toolItems = getMessageTools(msg);
+        const contentItems = formatMessage(msg)
+          .map(content => ({
+            role: roleMap[msg.origin] || 'assistant',
+            content: content,
+            type: 'message'
+          }))
+          .filter(item => item.content);
+        return [...toolItems, ...contentItems];
+      });
 
       return [...context, ...additional];
     } catch (error) {

package/lib/observability/index.js

@@ -1,6 +1,6 @@
 const { trace, metrics } = require('@opentelemetry/api');
 
-const { initTelemetry, shutdownTelemetry, getMetricsRequestHandler } = require('../observability/telemetry');
+const { initTelemetry, shutdownTelemetry } = require('../observability/telemetry');
 
 const tracer = trace.getTracer('nexus-assistant');
 const meter = metrics.getMeter('nexus-assistant');
@@ -149,7 +149,6 @@ function recordFileOperation(operationType, attributes = {}) {
 module.exports = {
   init,
   shutdown: shutdownTelemetry,
-  getMetricsRequestHandler,
   traceOperation,
   createSpan,
   tracer,

package/lib/observability/telemetry.js

@@ -1,6 +1,5 @@
 const { NodeSDK } = require('@opentelemetry/sdk-node');
 const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
-const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');
 const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
 const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
 const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-node');
@@ -11,13 +10,12 @@ const runtimeConfig = require('../config/runtimeConfig');
 
 const nodeEnv = runtimeConfig.get('NODE_ENV') || '';
 const isProd = nodeEnv === 'production' || nodeEnv === 'prod';
-const IGNORED_PATHS = ['/health', '/metrics', '/'];
+const IGNORED_PATHS = ['/health', '/'];
 
 class TelemetryManager {
   constructor() {
     this.sdk = null;
     this.isInitialized = false;
-    this.prometheusExporter = null;
   }
 
   async init(config = {}) {
@@ -32,8 +30,6 @@ class TelemetryManager {
       jaegerEndpoint = 'http://localhost:14268/api/traces',
       otlpEndpoint = null,
       otlpHeaders = {},
-      prometheusEndpoint = '/metrics',
-      prometheusPort = 9090
     } = config;
 
     try {
@@ -75,18 +71,12 @@ class TelemetryManager {
           exportTimeoutMillis: isProd ? 5000 : 2000,
           scheduledDelayMillis: isProd ? 2000 : 500,
         }),
-        metricReader: this.prometheusExporter = new PrometheusExporter({
-          endpoint: prometheusEndpoint,
-          port: prometheusPort,
-          preventServerStart: true,
-        }),
       });
 
       await this.sdk.start();
       this.isInitialized = true;
 
       console.log(`🚀 OpenTelemetry initialized for "${serviceName}"`);
-      console.log(`📊 Metrics: available at ${prometheusEndpoint} (mounted on Express app)`);
       console.log(`🔍 Traces: ${otlpEndpoint || jaegerEndpoint}`);
     } catch (error) {
       console.error('❌ Failed to initialize OpenTelemetry:', error.message);
@@ -115,8 +105,4 @@ module.exports = {
   telemetryManager,
   initTelemetry: (config) => telemetryManager.init(config),
   shutdownTelemetry: () => telemetryManager.shutdown(),
-  getMetricsRequestHandler: () => {
-    if (!telemetryManager.prometheusExporter) return null;
-    return (req, res) => telemetryManager.prometheusExporter.getMetricsRequestHandler(req, res);
-  }
 };

package/lib/providers/OpenAIResponsesProvider.js

@@ -115,11 +115,17 @@ class OpenAIResponsesProvider {
   }
 
   _convertItemsToApiFormat(items) {
-    return items.map(item => ({
-      role: item.role || 'user',
-      content: this._normalizeContent(item.content),
-      type: item.type || 'message',
-    }));
+    return items.map(item => {
+      const type = item.type || 'message';
+      if (type === 'function_call' || type === 'function_call_output') {
+        return { ...item, type };
+      }
+      return {
+        role: item.role || 'user',
+        type,
+        content: this._normalizeContent(item.content)
+      };
+    });
   }
 
   _normalizeContent(content) {
@@ -322,8 +328,8 @@ class OpenAIResponsesProvider {
       devContent += `\n\nYou only have access to these tools: ${toolNames}. Do not call or reference any tools not listed here.`;
     }
 
-    const messages = (context || this._convertItemsToApiFormat(additionalMessages))
-      .filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
+    const rawMessages = context || additionalMessages;
+    const messages = this._convertItemsToApiFormat(rawMessages);
     const input = [{ role: 'developer', content: devContent }, ...messages];
 
     const promptConfig = { id: assistantId };

package/lib/routes/index.js

@@ -176,12 +176,6 @@ const builtInControllers = {
 };
 
 const setupDefaultRoutes = (app) => {
-  const { getMetricsRequestHandler } = require('../observability');
-  const metricsHandler = getMetricsRequestHandler();
-  if (metricsHandler) {
-    app.get('/metrics', metricsHandler);
-  }
-
   app.use('/api/assistant', createRouter(assistantRouteDefinitions, builtInControllers));
   app.use('/api/conversation', createRouter(conversationRouteDefinitions, builtInControllers));
   app.use('/api/interaction', createRouter(interactionRouteDefinitions, builtInControllers));

package/lib/services/airtableService.js

@@ -2,6 +2,13 @@ const { airtable } = require('../config/airtableConfig');
 
 const { logger } = require('../utils/logger');
 
+let evalMode = false;
+
+function setEvalMode(enabled) {
+  evalMode = !!enabled;
+  logger.info(`[airtableService] Eval mode ${evalMode ? 'ON' : 'OFF'} — writes will be ${evalMode ? 'muted' : 'live'}`);
+}
+
 function getBase(baseID) {
   if (!airtable) throw new Error('Airtable not configured. Set AIRTABLE_API_KEY');
   return airtable.base(baseID);
@@ -17,6 +24,10 @@ async function collectRecords(query, mapper = r => r.fields) {
 }
 
 async function addRecord(baseID, tableName, fields) {
+  if (evalMode) {
+    logger.info('[addRecord:eval] Muted', { tableName });
+    return { id: 'eval_mock_record', fields: Array.isArray(fields) ? fields[0]?.fields || {} : fields };
+  }
   try {
     const record = await getBase(baseID)(tableName).create(fields);
     logger.info('[addRecord] Created', { tableName });
@@ -48,6 +59,10 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view')
 }
 
 async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
+  if (evalMode) {
+    logger.info('[updateRecordByFilter:eval] Muted', { tableName, filter });
+    return [{ id: 'eval_mock_record', fields: updateFields }];
+  }
   try {
     const base = getBase(baseID);
     const updatedRecords = [];
@@ -88,6 +103,7 @@ async function addLinkedRecord(baseID, targetTable, fields, linkConfig) {
 }
 
 module.exports = {
+  setEvalMode,
   addRecord,
   getRecords,
   getRecordByFilter,

package/lib/services/assistantService.js

@@ -159,8 +159,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     if (!thread) return null;
 
     const messagesStart = Date.now();
-    const beforeCheckpoint = message_?.createdAt ? 
-      (message_.createdAt.$date ? new Date(message_.createdAt.$date) : message_.createdAt) : null;
+    const beforeCheckpoint = message_?.createdAt ?? null;
     const lastMessage = await getLastNMessages(code, 1, beforeCheckpoint, {
       query: { from_me: false }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "3.3.18",
+  "version": "3.4.0-fix-version",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",
@@ -58,19 +58,18 @@
     "postversion": "git push && git push --tags"
   },
   "dependencies": {
-    "body-parser": "^1.20.2",
     "@opentelemetry/api": "1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "0.67.0",
+    "@opentelemetry/auto-instrumentations-node": "0.53.0",
     "@opentelemetry/exporter-jaeger": "1.28.0",
-    "@opentelemetry/exporter-prometheus": "0.56.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.56.0",
     "@opentelemetry/resources": "1.28.0",
     "@opentelemetry/sdk-node": "0.56.0",
     "@opentelemetry/sdk-trace-node": "1.28.0",
     "@opentelemetry/semantic-conventions": "1.28.0",
     "airtable": "^0.12.2",
-    "aws-sdk": "2.1693.0",
+    "aws-sdk": "^2.1693.0",
     "axios": "^1.5.0",
+    "body-parser": "^1.20.2",
     "dotenv": "^16.6.1",
     "moment-timezone": "^0.5.43",
     "mongoose": "^7.5.0",
@@ -108,6 +107,9 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "overrides": {
+    "p-limit": "2.3.0"
+  },
   "publishConfig": {
     "access": "public"
   }