@peopl-health/nexus 3.13.2 → 3.13.3

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, runDirect = null }) {
-    Object.assign(this, { mode, queueAdapter, sendMessage, replyAssistant, runDirect });
+  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 }) {
@@ -35,8 +76,13 @@ class AssistantProcessor {
 
   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);
+
+    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) {
@@ -45,7 +91,6 @@ class AssistantProcessor {
     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,8 @@ class NexusMessaging {
       mode: config.assistant?.mode || 'local',
       queueAdapter: this.queueAdapter,
       sendMessage: this.sendMessage.bind(this),
-      replyAssistant,
-      runDirect
+      preProcessMessages,
+      storeRunMetrics,
     });
   }
 

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

@@ -558,23 +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>;
-    runDirect?: (code: string, runOptions?: Record<string, 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>;
-    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>;
+    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');
@@ -124,38 +122,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 = {
@@ -172,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)
@@ -184,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');
@@ -198,128 +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 };
-  } 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
-    };
+    return { shouldProcess: true, messages: lastMessage, timings };
   } catch (error) {
-    logger.error('[runDirect] Error', { error: error.message, code });
+    logger.error('[preProcessMessages] Error', { error: error.message, code });
     throw error;
   }
 };
@@ -370,15 +253,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.3",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",