@peopl-health/nexus 3.13.2 → 3.13.4

package/lib/core/AssistantProcessor.js

@@ -1,51 +1,75 @@
-/**
- * Handles assistant message processing with local or queue modes.
- */
+const { sanitizeOutput } = require('../utils/formatUtils');
+const { getThread } = require('../helpers/threadHelper');
+const { runAssistantWithRetries } = require('../helpers/assistantHelper');
+const { getAssistantById } = require('../services/assistantResolver');
+
 class AssistantProcessor {
-  constructor({ mode = 'local', queueAdapter = null, sendMessage = null, replyAssistant = null, runDirect = null }) {
-    Object.assign(this, { mode, queueAdapter, sendMessage, replyAssistant, runDirect });
+  constructor({ mode = 'local', queueAdapter = null, sendMessage = null, storeRunMetrics = null }) {
+    Object.assign(this, { mode, queueAdapter, sendMessage, storeRunMetrics });
     if (mode === 'queue' && queueAdapter) {
-      queueAdapter.process('assistant.process', (payload) => this._processLocal(payload));
+      queueAdapter.process('assistant.process', (payload) => this._executeLocal(payload));
     }
   }
 
-  setReplyAssistant(fn) { this.replyAssistant = fn; }
   setSendMessage(fn) { this.sendMessage = fn; }
 
-  async process({ code, body = null, runOptions = {} }) {
-    if (!code) throw new Error('code is required for assistant processing');
+  async resolveThread(code) {
+    const thread = await getThread(code);
+    if (!thread) return null;
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
+    return { thread, assistant };
+  }
 
-    const result = (this.mode === 'queue')
-      ? await this._processViaQueue({ code, body, runOptions })
-      : await this._processLocal({ code, body, runOptions });
+  async executeLLM(thread, assistant, runOptions = {}, messages = null) {
+    const startTime = Date.now();
+    const runResult = await runAssistantWithRetries(thread, assistant, runOptions, messages);
+    const predictionTimeMs = Date.now() - startTime;
 
-    return result;
+    const output = sanitizeOutput(runResult?.output);
+    const run = runResult?.run;
+
+    return {
+      output,
+      tools_executed: runResult?.tools_executed,
+      prompt: run?.prompt || null,
+      preset: run?.preset || null,
+      response_id: run?.id || null,
+      run,
+      predictionTimeMs,
+      retries: runResult?.retries || 0,
+      completed: runResult?.completed,
+    };
+  }
+
+  async process({ code, runOptions = {}, messages = null }) {
+    if (!code) throw new Error('code is required for assistant processing');
+
+    return (this.mode === 'queue')
+      ? await this._executeViaQueue({ code, runOptions })
+      : await this._executeLocal({ code, runOptions, messages });
   }
 
-  async _processLocal({ code, body = null, runOptions = {} }) {
-    if (!this.replyAssistant) throw new Error('replyAssistant function not configured');
-    return await this.replyAssistant(code, body, null, runOptions);
+  async _executeLocal({ code, runOptions = {}, messages = null }) {
+    const resolved = await this.resolveThread(code);
+    if (!resolved) return null;
+
+    const result = await this.executeLLM(resolved.thread, resolved.assistant, runOptions, messages);
+    if (this.storeRunMetrics) await this.storeRunMetrics(code, resolved.thread, result);
+    return result;
   }
 
-  async _processViaQueue({ code, body, runOptions }) {
+  async _executeViaQueue({ code, runOptions }) {
     if (!this.queueAdapter) throw new Error('queueAdapter is required for queue mode');
-    const jobId = await this.queueAdapter.enqueue('assistant.process', { code, body, runOptions });
+    const jobId = await this.queueAdapter.enqueue('assistant.process', { code, runOptions });
     return await this.queueAdapter.waitForResult(jobId, 120000);
   }
 
-  async processDirect({ code, runOptions = {} }) {
-    if (!code) throw new Error('code is required for direct processing');
-    if (!this.runDirect) throw new Error('runDirect function not configured');
-    return await this.runDirect(code, runOptions);
-  }
-
   async sendResponse(code, result) {
     if (!this.sendMessage) throw new Error('sendMessage function not configured');
     if (!result?.output) return null;
     await this.sendMessage({ code, body: result.output, processed: true, origin: 'assistant', tools_executed: result.tools_executed, prompt: result.prompt, preset: result.preset, response_id: result.response_id });
     return result.output;
   }
-
 }
 
 module.exports = { AssistantProcessor };

package/lib/core/NexusMessaging.js

@@ -11,10 +11,11 @@ const { Thread } = require('../models/threadModel');
 
 const { setEventBus: setStatusEventBus } = require('../helpers/messageStatusHelper');
 const { ensureThreadExists } = require('../helpers/threadHelper');
+const { storeRunMetrics } = require('../helpers/metricsHelper');
 
 const { createMessagingProvider } = require('../adapters/registry');
 
-const { addMsgAssistant, replyAssistant, runDirect } = require('../services/assistantService');
+const { addMsgAssistant, preProcessMessages } = require('../services/assistantService');
 const { hasPreprocessingHandler, invokePreprocessingHandler } = require('../services/preprocessingService');
 
 const { BatchingManager } = require('../core/BatchingManager');
@@ -76,8 +77,7 @@ class NexusMessaging {
       mode: config.assistant?.mode || 'local',
       queueAdapter: this.queueAdapter,
       sendMessage: this.sendMessage.bind(this),
-      replyAssistant,
-      runDirect
+      storeRunMetrics,
     });
   }
 
@@ -383,9 +383,22 @@ class NexusMessaging {
   async _handleWithCheckAfter(chatId) {
     await this._executeWithPipeline(chatId, 'message', 'preempt',
       async (preProcessResult, shouldContinue) => {
-        return await this._processMessages(chatId, () =>
-          this.assistantProcessor.process({ code: chatId, runOptions: { prePromptResult: preProcessResult } })
-        , shouldContinue);
+        return await this._processMessages(chatId, async () => {
+          const resolved = await this.assistantProcessor.resolveThread(chatId);
+          if (!resolved) return null;
+
+          const preProcessed = await preProcessMessages(chatId, null, resolved.thread);
+          if (!preProcessed.shouldProcess) return null;
+
+          const result = await this.assistantProcessor.executeLLM(
+            resolved.thread, resolved.assistant,
+            { prePromptResult: preProcessResult },
+            preProcessed.messages
+          );
+
+          if (storeRunMetrics) await storeRunMetrics(chatId, resolved.thread, result, preProcessed.timings);
+          return { ...result, timings: preProcessed.timings };
+        }, shouldContinue);
       }
     );
   }
@@ -406,7 +419,7 @@ class NexusMessaging {
 
     const result = await this._executeWithPipeline(code, 'instruction', 'queue',
       async (preProcessResult) => {
-        return await this.assistantProcessor.processDirect({
+        return await this.assistantProcessor.process({
           code,
           runOptions: {
             prePromptResult: preProcessResult,
@@ -441,7 +454,7 @@ class NexusMessaging {
 
     const result = await this._executeWithPipeline(code, 'system', 'queue',
       async (preProcessResult) => {
-        return await this.assistantProcessor.processDirect({
+        return await this.assistantProcessor.process({
           code,
           runOptions: {
             prePromptResult: preProcessResult,

package/lib/helpers/filesHelper.js

@@ -3,9 +3,6 @@ const fsSync = require('fs');
 const path = require('path');
 const { execFile } = require('child_process');
 
-const sharp = require('sharp');
-const { PDFDocument } = require('pdf-lib');
-
 const { downloadFileFromS3 } = require('../config/awsConfig.js');
 
 const { sanitizeFilename } = require('../utils/sanitizerUtils.js');
@@ -76,43 +73,6 @@ async function convertPdfToImages(pdfName, existingPdfPath = null) {
   });
 }
 
-async function combineImagesToPDF(config) {
-  const { code, extensions = ['jpg', 'jpeg', 'png', 'tiff'], sortNumerically = true } = config;
-  const inputDir = path.join(__dirname, 'assets', 'tmp');
-  const files = await fs.readdir(inputDir);
-
-  const imageFiles = files.filter(file => {
-    const ext = path.extname(file).toLowerCase().slice(1);
-    return extensions.includes(ext) && (!code || file.startsWith(code));
-  });
-
-  imageFiles.sort((a, b) => {
-    if (!sortNumerically) return a.localeCompare(b);
-    const aNum = a.match(/\d+/)?.[0];
-    const bNum = b.match(/\d+/)?.[0];
-    return (aNum && bNum) ? parseInt(aNum) - parseInt(bNum) : a.localeCompare(b);
-  });
-
-  const pdfDoc = await PDFDocument.create();
-  const processedFiles = [];
-
-  for (const file of imageFiles) {
-    try {
-      const filePath = path.join(inputDir, file);
-      const imageBuffer = await fs.readFile(filePath);
-      const pngBuffer = await sharp(imageBuffer).toFormat('png').toBuffer();
-      const { width, height } = await sharp(imageBuffer).metadata();
-      const img = await pdfDoc.embedPng(pngBuffer);
-      pdfDoc.addPage([width, height]).drawImage(img, { x: 0, y: 0, width, height });
-      processedFiles.push(filePath);
-    } catch (error) {
-      logger.error(`Error processing file ${file}`, { error: error.message });
-    }
-  }
-
-  return { pdfBuffer: await pdfDoc.save(), processedFiles };
-}
-
 const cleanupFiles = async (files) => {
   if (!files?.length) return;
 
@@ -168,7 +128,6 @@ async function downloadMediaAndCreateFile(code, reply) {
 
 module.exports = {
   convertPdfToImages,
-  combineImagesToPDF,
   cleanupFiles,
   downloadMediaAndCreateFile
 };

package/lib/helpers/metricsHelper.js

@@ -0,0 +1,62 @@
+const { logger } = require('../utils/logger');
+const { getPredictionMetrics } = require('../models/predictionMetricsModel');
+
+const storeRunMetrics = async (code, thread, result, timings = {}) => {
+  const { output, run, predictionTimeMs, retries, completed } = result;
+  if (!output || !predictionTimeMs) return;
+
+  const usage = run?.usage || null;
+  const model = run?.model || null;
+
+  logger.info('[Assistant Reply Complete]', {
+    code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+    retries,
+    totalMs: timings.total_ms,
+    toolsExecuted: result.tools_executed?.length || 0,
+    token_usage: usage ? {
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens,
+      total_tokens: usage.total_tokens,
+      model,
+    } : undefined,
+  });
+
+  const tokenUsage = usage ? {
+    input_tokens: usage.input_tokens || 0,
+    output_tokens: usage.output_tokens || 0,
+    total_tokens: usage.total_tokens || 0,
+    model: model || undefined,
+  } : undefined;
+
+  await getPredictionMetrics().create({
+    message_id: `${code}-${Date.now()}`,
+    numero: code,
+    assistant_id: thread.getAssistantId(),
+    prediction_time_ms: predictionTimeMs,
+    retry_count: retries,
+    completed,
+    timing_breakdown: timings,
+    token_usage: tokenUsage,
+    prompt_config: run?.prompt || null,
+    response_id: run?.id || null,
+    resolved_prompt: run?.resolved_prompt || null,
+    snippet_ids: run?.snippet_ids || [],
+    tool_ids: run?.tool_ids || [],
+    preset_id: run?.preset_id || null,
+    preset_version: run?.preset_version || null,
+    preset: run?.preset || null,
+  }).catch(err => logger.error('[storeRunMetrics] Failed to store metrics', { error: err.message }));
+
+  const alertThreshold = parseInt(process.env.TOKEN_ALERT_THRESHOLD, 10);
+  if (alertThreshold && usage?.total_tokens > alertThreshold) {
+    logger.warn('[storeRunMetrics] Token usage spike detected', {
+      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+      total_tokens: usage.total_tokens,
+      threshold: alertThreshold,
+      model,
+      assistant_id: thread.getAssistantId(),
+    });
+  }
+};
+
+module.exports = { storeRunMetrics };

package/lib/helpers/processHelper.js

@@ -138,6 +138,15 @@ const processMediaFilesCore = async (code, reply, provider) => {
   
   if (!reply.media) return { messagesChat: [], url: null, tempFiles: [], timings };
 
+  if (reply.media?.metadata?.processedContent) {
+    return {
+      messagesChat: [{ type: 'text', text: reply.media.metadata.processedContent }],
+      url: null,
+      tempFiles: [],
+      timings
+    };
+  }
+
   const { result: fileNames, duration } = await withTracing(
     downloadMediaAndCreateFile, 'download_media',
     () => ({ 'media.message_id': reply.message_id, 'media.type': reply.media?.mediaType }),

package/lib/index.d.ts

@@ -558,23 +558,33 @@ declare module '@peopl-health/nexus' {
     mode?: 'local' | 'queue';
     queueAdapter?: QueueAdapter;
     sendMessage?: (messageData: MessageData) => Promise<any>;
-    replyAssistant?: (code: string, body?: string, thread?: any, options?: any) => Promise<any>;
-    runDirect?: (code: string, runOptions?: Record<string, any>) => Promise<any>;
+    storeRunMetrics?: (code: string, thread: any, result: any, timings?: Record<string, any>) => Promise<void>;
   }
 
   export interface ProcessInput {
     code: string;
-    messageData: MessageData;
-    thread?: any;
     runOptions?: Record<string, any>;
+    messages?: any[] | null;
+  }
+
+  export interface LLMResult {
+    output: string;
+    tools_executed?: any[];
+    prompt?: string | null;
+    preset?: string | null;
+    response_id?: string | null;
+    run?: any;
+    predictionTimeMs?: number;
+    retries?: number;
+    completed?: boolean;
   }
 
   export class AssistantProcessor {
     constructor(config: AssistantProcessorConfig);
-    setReplyAssistant(fn: AssistantProcessorConfig['replyAssistant']): void;
     setSendMessage(fn: AssistantProcessorConfig['sendMessage']): void;
-    process(input: ProcessInput): Promise<{ output: string; tools_executed?: any[]; prompt?: string; response_id?: string } | null>;
-    processDirect(input: { code: string; runOptions?: Record<string, any> }): Promise<{ output: string; tools_executed?: any[]; prompt?: string; response_id?: string } | null>;
+    resolveThread(code: string): Promise<{ thread: any; assistant: any } | null>;
+    executeLLM(thread: any, assistant: any, runOptions?: Record<string, any>, messages?: any[]): Promise<LLMResult>;
+    process(input: ProcessInput): Promise<LLMResult | null>;
     sendResponse(code: string, result: any): Promise<string | null>;
   }
 }

package/lib/services/assistantService.js

@@ -1,20 +1,17 @@
-const AWS = require('../config/awsConfig.js');
 const runtimeConfig = require('../config/runtimeConfig');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 
 const { logger } = require('../utils/logger');
-const { sanitizeOutput } = require('../utils/formatUtils');
 const { withTracing } = require('../utils/tracingDecorator.js');
 
 const { Thread } = require('../models/threadModel.js');
-const { getPredictionMetrics } = require('../models/predictionMetricsModel');
 const { insertMessage } = require('../models/messageModel');
 
-const { getCurRow, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
+const { getCurRow } = require('../helpers/assistantHelper.js');
 const { getThread, switchThreadStoppedStatus, setThreadPromptId } = require('../helpers/threadHelper.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
 const { getLastNMessages, storeProcessedContent } = require('../helpers/messageHelper.js');
-const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
+const { cleanupFiles } = require('../helpers/filesHelper.js');
 
 const { createLLMProvider } = require('../providers/createLLMProvider');
 const { getAssistantById } = require('./assistantResolver');
@@ -124,38 +121,31 @@ const addInstructionCore = async (code, instruction, role = 'system') => {
   }
 };
 
-const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}) => {
+const preProcessMessagesCore = async (code, message_ = null, thread) => {
   const timings = {};
-  const startTotal = Date.now();
-  
-  try {
-    const threadStart = Date.now();
-    const thread = thread_ || await getThread(code);
-    timings.get_thread_ms = Date.now() - threadStart;
-    
-    if (!thread) return null;
 
+  try {
     const messagesStart = Date.now();
     const beforeCheckpoint = message_?.createdAt ?? null;
     const lastMessage = await getLastNMessages(code, 1, beforeCheckpoint, {
       query: { from_me: false }
     });
     timings.get_messages_ms = Date.now() - messagesStart;
-    
+
     if (!lastMessage || lastMessage.length === 0) {
-      logger.info('[replyAssistant] No relevant data found for this assistant.');
-      return null;
+      logger.info('[preProcessMessages] No relevant data found for this assistant.');
+      return { shouldProcess: false, messages: null, timings };
     }
 
     const provider = createLLMProvider({ variant: runtimeConfig.get('VARIANT') });
-    logger.info(`[replyAssistant] Processing ${lastMessage.length} messages in parallel`);
+    logger.info(`[preProcessMessages] Processing ${lastMessage.length} messages in parallel`);
     const processStart = Date.now();
     const processResult = await processThreadMessage(code, lastMessage, provider);
-    
+
     const { results: processResults, timings: processTimings } = processResult;
     timings.process_messages_ms = Date.now() - processStart;
-    
-    logger.debug('[replyAssistant] Process timings breakdown', { processTimings });
+
+    logger.debug('[preProcessMessages] Process timings breakdown', { processTimings });
 
     if (processTimings) {
       timings.process_messages_breakdown = {
@@ -168,11 +158,10 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     }
 
     const patientMsg = processResults.some(r => r.isPatient);
-    const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
     const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
 
     await Promise.all(processResults.map(r => {
-      const processedContent = r.messages && r.messages.length > 0 
+      const processedContent = r.messages && r.messages.length > 0
         ? r.messages
           .filter(msg => msg.content.text !== r.reply?.body)
           .map(msg => msg.content.text)
@@ -183,143 +172,14 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
     await cleanupFiles(allTempFiles);
 
-    if (urls.length > 0) {
-      logger.info(`[replyAssistant] Processing ${urls.length} URLs for PDF combination`);
-      const pdfStart = Date.now();
-      const pdfResult = await combineImagesToPDF({ code });
-      timings.pdf_combination_ms = Date.now() - pdfStart;
-      const { pdfBuffer, processedFiles } = pdfResult;
-      logger.info(`[replyAssistant] PDF combination complete: ${processedFiles?.length || 0} files processed`);
-      
-      if (pdfBuffer) {
-        const key = `${code}-${Date.now()}-combined.pdf`;
-        const bucket = runtimeConfig.get('AWS_S3_BUCKET_NAME');
-        if (bucket) {
-          await AWS.uploadBufferToS3(pdfBuffer, bucket, key, 'application/pdf');
-        }
-      }
-      
-      if (processedFiles && processedFiles.length) {
-        await cleanupFiles(processedFiles);
-      }
-    }
-
     if (!patientMsg || thread.stopped) {
-      logger.info('[replyAssistant] Skipping AI processing', { patientMsg, stopped: thread.stopped, code });
-      return null;
-    }
-
-    const assistant = getAssistantById(thread.getAssistantId(), thread);
-    const runStart = Date.now();
-    const runResult = await runAssistantWithRetries(thread, assistant, runOptions, lastMessage);
-    timings.run_assistant_ms = Date.now() - runStart;
-    timings.total_ms = Date.now() - startTotal;
-    
-    const { output: rawOutput, completed, retries, predictionTimeMs, tools_executed } = runResult;
-    const run = runResult.run;
-    const usage = run?.usage || null;
-    const model = run?.model || null;
-    
-    const output = sanitizeOutput(rawOutput);
-    if (rawOutput !== output) {
-      logger.debug('[replyAssistant] Output sanitized', {
-        originalLength: rawOutput?.length || 0,
-        sanitizedLength: output?.length || 0,
-        removedContent: rawOutput?.length ? 'brackets_removed' : 'none'
-      });
-    }
-
-    logger.info('[Assistant Response]', { output });
-    logger.info('[Assistant Reply Complete]', {
-      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-      messageCount: lastMessage.length,
-      hasMedia: urls.length > 0,
-      retries,
-      totalMs: timings.total_ms,
-      toolsExecuted: tools_executed?.length || 0,
-      token_usage: usage ? {
-        input_tokens: usage.input_tokens,
-        output_tokens: usage.output_tokens,
-        total_tokens: usage.total_tokens,
-        model,
-      } : undefined,
-    });
-
-    if (output && predictionTimeMs) {
-      logger.debug('[replyAssistant] Storing metrics with timing_breakdown', {
-        timing_breakdown: timings,
-        has_breakdown: !!timings.process_messages_breakdown
-      });
-
-      const tokenUsage = usage ? {
-        input_tokens: usage.input_tokens || 0,
-        output_tokens: usage.output_tokens || 0,
-        total_tokens: usage.total_tokens || 0,
-        model: model || undefined,
-      } : undefined;
-
-      await getPredictionMetrics().create({
-        message_id: `${code}-${Date.now()}`,
-        numero: code,
-        assistant_id: thread.getAssistantId(),
-        prediction_time_ms: predictionTimeMs,
-        retry_count: retries,
-        completed: completed,
-        timing_breakdown: timings,
-        token_usage: tokenUsage,
-        prompt_config: run?.prompt || null,
-        response_id: run?.id || null,
-        context_message_count: lastMessage?.length || null,
-        resolved_prompt: run?.resolved_prompt || null,
-        snippet_ids: run?.snippet_ids || [],
-        tool_ids: run?.tool_ids || [],
-        preset_id: run?.preset_id || null,
-        preset_version: run?.preset_version || null,
-        preset: run?.preset || null,
-      }).catch(err => logger.error('[replyAssistant] Failed to store metrics', { error: err.message }));
-
-      const alertThreshold = parseInt(process.env.TOKEN_ALERT_THRESHOLD, 10);
-      if (alertThreshold && usage?.total_tokens > alertThreshold) {
-        logger.warn('[replyAssistant] Token usage spike detected', {
-          code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-          total_tokens: usage.total_tokens,
-          threshold: alertThreshold,
-          model,
-          assistant_id: thread.getAssistantId(),
-        });
-      }
+      logger.info('[preProcessMessages] Skipping AI processing', { patientMsg, stopped: thread.stopped, code });
+      return { shouldProcess: false, messages: null, timings };
     }
 
-    return { output, tools_executed, prompt: run?.prompt || null, preset: run?.preset || null, response_id: run?.id || null };
+    return { shouldProcess: true, messages: lastMessage, timings };
   } catch (error) {
-    logger.error('[replyAssistant] Error in reply', { 
-      error: error.message,
-      stack: error.stack,
-      code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
-      hasCustomThread: !!thread_,
-      hasMessage: !!message_
-    });
-    throw error;
-  }
-};
-
-const runDirectCore = async (code, runOptions = {}) => {
-  const thread = await getThread(code);
-  if (!thread) return null;
-
-  try {
-    const assistant = getAssistantById(thread.getAssistantId(), thread);
-    const runResult = await runAssistantWithRetries(thread, assistant, runOptions);
-    const output = sanitizeOutput(runResult?.output);
-    return {
-      output,
-      tools_executed: runResult?.tools_executed,
-      prompt: runResult?.run?.prompt || null,
-      preset: runResult?.run?.preset || null,
-      response_id: runResult?.run?.id || null
-    };
-  } catch (error) {
-    logger.error('[runDirect] Error', { error: error.message, code });
+    logger.error('[preProcessMessages] Error', { error: error.message, code });
     throw error;
   }
 };
@@ -370,15 +230,9 @@ module.exports = {
     'instruction.role': role,
     'operation.type': 'add_instruction'
   })),
-  replyAssistant: withTracing(replyAssistantCore, 'assistant_reply', (code, message_, thread_, runOptions) => ({
-    'assistant.thread_code': code,
-    'assistant.has_message': !!message_,
-    'assistant.has_custom_thread': !!thread_,
-    'assistant.has_run_options': !!runOptions && Object.keys(runOptions).length > 0
-  })),
-  runDirect: withTracing(runDirectCore, 'run_direct', (code) => ({
+  preProcessMessages: withTracing(preProcessMessagesCore, 'pre_process_messages', (code) => ({
     'assistant.thread_code': code,
-    'operation.type': 'run_direct'
+    'operation.type': 'pre_process_messages'
   })),
   switchAssistant: withTracing(switchAssistantCore, 'switch_assistant', (code, assistant_id) => ({
     'assistant.thread_code': code,

package/package.json

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