@peopl-health/nexus 3.13.1 → 3.13.3

package/lib/controllers/assistantController.js

@@ -5,9 +5,9 @@ const { logger } = require('../utils/logger');
 const { getThreadInfo, switchThreadStoppedStatus } = require('../helpers/threadHelper');
 
 const { getRecordByFilter } = require('../services/airtableService');
-const { createAssistant, addMsgAssistant, addInsAssistant, switchAssistant } = require('../services/assistantService');
+const { createAssistant, addMsgAssistant, switchAssistant } = require('../services/assistantService');
 
-const { sendMessage } = require('../core/NexusMessaging');
+const { sendMessage, processInstruction, processSystemMessage } = require('../core/NexusMessaging');
 
 const _updateThreadFlag = async (req, res, field, successMsg, errorMsg) => {
   const { code } = req.body;
@@ -36,8 +36,7 @@ const addInsAssistantController = async (req, res) => {
   if (!code) return res.status(400).json({ success: false, error: 'Code is required' });
 
   try {
-    const reply = await addInsAssistant(code, instruction, 'developer');
-    if (reply) await sendMessage({ code, body: reply, fileType: 'text', origin: 'assistant' });
+    await processInstruction(code, instruction, 'developer');
     return res.status(200).json({ success: true, message: 'Instruction added to assistant' });
   } catch (error) {
     logger.error('[AssistantController] Add instruction error', { error: error.message, code });
@@ -50,8 +49,11 @@ const addMsgAssistantController = async (req, res) => {
   if (!code) return res.status(400).json({ success: false, error: 'Code is required' });
 
   try {
-    const assistantReply = await addMsgAssistant(code, messages, role, reply);
-    if (assistantReply) await sendMessage({ code, body: assistantReply, fileType: 'text', origin: 'assistant' });
+    if (reply) {
+      await processSystemMessage(code, messages, role);
+    } else {
+      await addMsgAssistant(code, messages, role);
+    }
     return res.status(200).json({ success: true, message: 'Message added to assistant' });
   } catch (error) {
     logger.error('[AssistantController] Add message error', { error: error.message, code, role });

package/lib/core/AssistantProcessor.js

@@ -1,30 +1,71 @@
-/**
- * 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 }) {
-    Object.assign(this, { mode, queueAdapter, sendMessage, replyAssistant });
+  constructor({ mode = 'local', queueAdapter = null, sendMessage = null, preProcessMessages = null, storeRunMetrics = null }) {
+    Object.assign(this, { mode, queueAdapter, sendMessage, preProcessMessages, storeRunMetrics });
     if (mode === 'queue' && queueAdapter) {
-      queueAdapter.process('assistant.process', (payload) => this._processLocal(payload));
+      queueAdapter.process('assistant.process', (payload) => this._processViaLocal(payload));
     }
   }
 
-  setReplyAssistant(fn) { this.replyAssistant = fn; }
   setSendMessage(fn) { this.sendMessage = fn; }
 
+  async resolveThread(code) {
+    const thread = await getThread(code);
+    if (!thread) return null;
+    const assistant = getAssistantById(thread.getAssistantId(), thread);
+    return { thread, assistant };
+  }
+
+  async executeLLM(thread, assistant, runOptions = {}, messages = null) {
+    const startTime = Date.now();
+    const runResult = await runAssistantWithRetries(thread, assistant, runOptions, messages);
+    const predictionTimeMs = Date.now() - startTime;
+
+    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, body = null, runOptions = {} }) {
     if (!code) throw new Error('code is required for assistant processing');
 
-    const result = (this.mode === 'queue')
+    return (this.mode === 'queue')
       ? await this._processViaQueue({ code, body, runOptions })
-      : await this._processLocal({ code, body, runOptions });
-
-    return result;
+      : await this._processViaLocal({ code, body, runOptions });
   }
 
-  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 _processViaLocal({ code, body = null, runOptions = {} }) {
+    const resolved = await this.resolveThread(code);
+    if (!resolved) return null;
+    const { thread, assistant } = resolved;
+
+    if (this.preProcessMessages) {
+      const preProcessed = await this.preProcessMessages(code, body, thread);
+      if (!preProcessed.shouldProcess) return null;
+
+      const result = await this.executeLLM(thread, assistant, runOptions, preProcessed.messages);
+      if (this.storeRunMetrics) await this.storeRunMetrics(code, thread, result, preProcessed.timings);
+      return { ...result, timings: preProcessed.timings };
+    }
+
+    const result = await this.executeLLM(thread, assistant, runOptions);
+    if (this.storeRunMetrics) await this.storeRunMetrics(code, thread, result);
+    return result;
   }
 
   async _processViaQueue({ code, body, runOptions }) {
@@ -33,13 +74,23 @@ class AssistantProcessor {
     return await this.queueAdapter.waitForResult(jobId, 120000);
   }
 
+  async processDirect({ code, runOptions = {} }) {
+    if (!code) throw new Error('code is required for direct processing');
+
+    const resolved = await this.resolveThread(code);
+    if (!resolved) return null;
+
+    const result = await this.executeLLM(resolved.thread, resolved.assistant, runOptions);
+    if (this.storeRunMetrics) await this.storeRunMetrics(code, resolved.thread, result);
+    return result;
+  }
+
   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

@@ -6,15 +6,16 @@ const { connect } = require('../config/mongoConfig');
 
 const { logger } = require('../utils/logger');
 
-const { Message } = require('../models/messageModel');
+const { Message, insertMessage } = require('../models/messageModel');
 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 } = require('../services/assistantService');
+const { addMsgAssistant, preProcessMessages } = require('../services/assistantService');
 const { hasPreprocessingHandler, invokePreprocessingHandler } = require('../services/preprocessingService');
 
 const { BatchingManager } = require('../core/BatchingManager');
@@ -76,7 +77,8 @@ class NexusMessaging {
       mode: config.assistant?.mode || 'local',
       queueAdapter: this.queueAdapter,
       sendMessage: this.sendMessage.bind(this),
-      replyAssistant
+      preProcessMessages,
+      storeRunMetrics,
     });
   }
 
@@ -350,29 +352,112 @@ class NexusMessaging {
   }
 
   /*
-   * MESSAGE BATCHING
+   * PROCESSING PIPELINE
    */
 
-  async _handleWithCheckAfter(chatId) {
+  async _executeWithPipeline(chatId, type, mode, executeFn) {
+    let capturedResult = null;
+
     const processingFn = async (runId) => {
       const shouldContinue = () => this.batchingManager.isActiveRun(chatId, runId);
-
-      return await this.pipeline.run(
-        { chatId, runId, type: 'message' },
-        async (preProcessResult) => {
-          return await this._processMessages(chatId, () =>
-            this.assistantProcessor.process({ code: chatId, runOptions: { runId, prePromptResult: preProcessResult } })
-          , shouldContinue);
-        },
+      capturedResult = await this.pipeline.run(
+        { chatId, runId, type },
+        executeFn,
         shouldContinue
       );
+      return capturedResult;
     };
 
     const sendResponseFn = async (result) => {
       await this.assistantProcessor.sendResponse(chatId, result);
     };
 
-    await this.batchingManager.handleBatchedProcessing(chatId, processingFn, sendResponseFn);
+    if (mode === 'queue') {
+      await this.batchingManager.enqueueProcessing(chatId, processingFn, sendResponseFn);
+    } else {
+      await this.batchingManager.handleBatchedProcessing(chatId, processingFn, sendResponseFn);
+    }
+
+    return capturedResult;
+  }
+
+  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);
+      }
+    );
+  }
+
+  async processInstruction(code, instruction, role = 'developer') {
+    const assistantId = await this._getThreadAssistantId(code);
+    await insertMessage({
+      nombre_whatsapp: 'Instruction',
+      numero: code,
+      body: instruction,
+      message_id: `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      from_me: true,
+      processed: true,
+      origin: 'instruction',
+      assistant_id: assistantId,
+      raw: { role }
+    });
+
+    const result = await this._executeWithPipeline(code, 'instruction', 'queue',
+      async (preProcessResult) => {
+        return await this.assistantProcessor.processDirect({
+          code,
+          runOptions: {
+            prePromptResult: preProcessResult,
+            additionalInstructions: instruction,
+            additionalMessages: [{ role, content: instruction }],
+            toolChoice: 'none',
+          }
+        });
+      }
+    );
+
+    return result?.output || null;
+  }
+
+  async processSystemMessage(code, messages, role = 'system') {
+    const normalizedMessages = Array.isArray(messages) ? messages : [messages];
+    const assistantId = await this._getThreadAssistantId(code);
+
+    for (let i = 0; i < normalizedMessages.length; i++) {
+      await insertMessage({
+        nombre_whatsapp: 'System',
+        numero: code,
+        body: normalizedMessages[i],
+        message_id: `system_${Date.now()}_${i}_${Math.random().toString(36).substring(7)}`,
+        from_me: true,
+        processed: true,
+        origin: 'system',
+        assistant_id: assistantId,
+        raw: { role }
+      });
+    }
+
+    const result = await this._executeWithPipeline(code, 'system', 'queue',
+      async (preProcessResult) => {
+        return await this.assistantProcessor.processDirect({
+          code,
+          runOptions: {
+            prePromptResult: preProcessResult,
+            toolChoice: 'none',
+          }
+        });
+      }
+    );
+
+    return result?.output || null;
+  }
+
+  async _getThreadAssistantId(code) {
+    const thread = await Thread.findOne({ code }).select('assistant_id prompt_id').lean();
+    return thread?.prompt_id || thread?.assistant_id || null;
   }
 
   async _processMessages(chatId, processingFn, shouldFinalize = () => true) {
@@ -450,6 +535,14 @@ const sendScheduledMessage = async (scheduledMessage) => {
   return await requireDefaultInstance().sendScheduledMessage(scheduledMessage);
 };
 
+const processInstruction = async (code, instruction, role) => {
+  return await requireDefaultInstance().processInstruction(code, instruction, role);
+};
+
+const processSystemMessage = async (code, messages, role) => {
+  return await requireDefaultInstance().processSystemMessage(code, messages, role);
+};
+
 const getEventBus = () => getDefaultInstance()?.getEventBus();
 
 const _resetDefaultInstance = () => { defaultInstance = null; };
@@ -458,8 +551,11 @@ module.exports = {
   NexusMessaging,
   sendMessage,
   sendScheduledMessage,
+  processInstruction,
+  processSystemMessage,
   setDefaultInstance,
   getDefaultInstance,
+  requireDefaultInstance,
   getProvider,
   requireProvider,
   getEventBus,

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/index.d.ts

@@ -246,6 +246,8 @@ declare module '@peopl-health/nexus' {
     getBatchingManager(): BatchingManager;
     getPipeline(): ProcessingPipeline;
     getAssistantProcessor(): AssistantProcessor;
+    processInstruction(code: string, instruction: string, role?: string): Promise<string | null>;
+    processSystemMessage(code: string, messages: string | string[], role?: string): Promise<string | null>;
     isConnected(): boolean;
     disconnect(): Promise<void>;
   }
@@ -556,21 +558,35 @@ 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>;
+    preProcessMessages?: (code: string, body: any, thread: any) => Promise<{ shouldProcess: boolean; messages: any[] | null; timings: Record<string, any> }>;
+    storeRunMetrics?: (code: string, thread: any, result: any, timings?: Record<string, any>) => Promise<void>;
   }
 
   export interface ProcessInput {
     code: string;
-    messageData: MessageData;
-    thread?: any;
+    body?: any;
     runOptions?: Record<string, any>;
   }
 
+  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>;
+    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>;
+    processDirect(input: { code: string; runOptions?: Record<string, any> }): Promise<LLMResult | null>;
     sendResponse(code: string, result: any): Promise<string | null>;
   }
 }

package/lib/services/assistantService.js

@@ -3,14 +3,12 @@ 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');
@@ -66,40 +64,34 @@ const createAssistantCore = async (code, assistant_id, _messages = [], force = f
   }
 };
 
-const addMsgAssistantCore = async (code, inMessages, role = 'system', reply = false, skipSystemMessage = false) => {
+const addMsgAssistantCore = async (code, inMessages, role = 'system') => {
   const thread = await getThread(code);
   if (!thread) return null;
 
   try {
     const messages = Array.isArray(inMessages) ? inMessages : [inMessages];
 
-    if (!skipSystemMessage) {
-      for (let i = 0; i < messages.length; i++) {
-        const message = messages[i];
-        try {
-          const message_id = `system_${Date.now()}_${i}_${Math.random().toString(36).substring(7)}`;
-          await insertMessage({
-            nombre_whatsapp: 'System',
-            numero: code,
-            body: message,
-            message_id: message_id,
-            from_me: true,
-            processed: true,
-            origin: 'system',
-            assistant_id: thread.getAssistantId(),
-            raw: { role: role }
-          });
-        } catch (err) {
-          logger.error('[addMsgAssistant] Error saving system message', { err });
-        }
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      try {
+        const message_id = `system_${Date.now()}_${i}_${Math.random().toString(36).substring(7)}`;
+        await insertMessage({
+          nombre_whatsapp: 'System',
+          numero: code,
+          body: message,
+          message_id: message_id,
+          from_me: true,
+          processed: true,
+          origin: 'system',
+          assistant_id: thread.getAssistantId(),
+          raw: { role: role }
+        });
+      } catch (err) {
+        logger.error('[addMsgAssistant] Error saving system message', { err });
       }
     }
 
-    if (!reply) return null;
-
-    const assistant = getAssistantById(thread.getAssistantId(), thread);
-    const runResult = await runAssistantWithRetries(thread, assistant, { toolChoice: 'none' });
-    return runResult?.output || null;
+    return null;
   } catch (error) {
     logger.error('[addMsgAssistant] Error adding message', { error: error.message, code, role });
     return null;
@@ -111,73 +103,50 @@ const addInstructionCore = async (code, instruction, role = 'system') => {
   if (!thread) return null;
 
   try {
-    const assistant = getAssistantById(thread.getAssistantId(), thread);
-
-    try {
-      const message_id = `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-      await insertMessage({
-        nombre_whatsapp: 'Instruction',
-        numero: code,
-        body: instruction,
-        message_id: message_id,
-        from_me: true,
-        processed: true,
-        origin: 'instruction',
-        assistant_id: thread.getAssistantId(),
-        raw: { role: role }
-      });
-    } catch (err) {
-      logger.error('[addInstruction] Error saving instruction message', { err });
-    }
-
-    const runResult = await runAssistantWithRetries(thread, assistant, {
-      additionalInstructions: instruction,
-      additionalMessages: [
-        { role: role, content: instruction }
-      ],
-      toolChoice: 'none'
+    const message_id = `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    await insertMessage({
+      nombre_whatsapp: 'Instruction',
+      numero: code,
+      body: instruction,
+      message_id: message_id,
+      from_me: true,
+      processed: true,
+      origin: 'instruction',
+      assistant_id: thread.getAssistantId(),
+      raw: { role: role }
     });
-
-    logger.info('[addInstruction] Run response', { output: runResult?.output });
-    return runResult?.output || null;
+    return null;
   } catch (error) {
     logger.error('[addInstruction] Error adding instruction', { error: error.message, code, role });
     return null;
   }
 };
 
-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 = {
@@ -194,7 +163,7 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     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)
@@ -206,13 +175,13 @@ 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`);
+      logger.info(`[preProcessMessages] 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`);
-      
+      logger.info(`[preProcessMessages] 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');
@@ -220,107 +189,20 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
           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;
+      logger.info('[preProcessMessages] Skipping AI processing', { patientMsg, stopped: thread.stopped, code });
+      return { shouldProcess: false, messages: null, timings };
     }
 
-    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(),
-        });
-      }
-    }
-
-    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_
-    });
+    logger.error('[preProcessMessages] Error', { error: error.message, code });
     throw error;
   }
 };
@@ -371,11 +253,9 @@ module.exports = {
     'instruction.role': role,
     'operation.type': 'add_instruction'
   })),
-  replyAssistant: withTracing(replyAssistantCore, 'assistant_reply', (code, message_, thread_, runOptions) => ({
+  preProcessMessages: withTracing(preProcessMessagesCore, 'pre_process_messages', (code) => ({
     'assistant.thread_code': code,
-    'assistant.has_message': !!message_,
-    'assistant.has_custom_thread': !!thread_,
-    'assistant.has_run_options': !!runOptions && Object.keys(runOptions).length > 0
+    '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.1",
+  "version": "3.13.3",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",