@peopl-health/nexus 3.3.16 → 3.3.18-fix-model

package/lib/adapters/TwilioProvider.js

@@ -145,7 +145,7 @@ class TwilioProvider extends MessageProvider {
       }
     } else {
       result = await this.twilioClient.messages.create(messageParams);
-      await saveMessage(messageParams.body, result);
+      await saveMessage(messageParams.body || messageData.body, result);
     }
     
     return {

package/lib/assistants/BaseAssistant.js

@@ -50,13 +50,21 @@ class BaseAssistant {
   registerTool(config) {
     const { name, handler, description, parameters, strict } = config;
 
+    const toolParams = parameters
+      ? { ...parameters }
+      : { type: 'object', properties: {} };
+
+    if (toolParams.additionalProperties === undefined) {
+      toolParams.additionalProperties = false;
+    }
+
     this.tools.set(name, {
       schema: {
         type: 'function',
         function: {
           name,
           description: description || 'Custom assistant tool',
-          parameters: parameters || { type: 'object', properties: {}, additionalProperties: true },
+          parameters: toolParams,
           ...(strict !== undefined && { strict })
         }
       },
@@ -71,7 +79,8 @@ class BaseAssistant {
   async executeTool(name, args) {
     const tool = this.tools.get(name);
     if (!tool) {
-      throw new Error(`Unknown tool '${name}' requested by assistant`);
+      logger.warn('[executeTool] Rejected unregistered tool', { name, assistantId: this.assistantId });
+      throw new Error(`Tool '${name}' is not available`);
     }
     return await tool.execute(args);
   }

package/lib/config/lifecycle.js

@@ -0,0 +1,19 @@
+const { _resetState: _resetLLMState } = require('../config/llmConfig');
+const { _resetOverrides } = require('../config/runtimeConfig');
+const { _resetMetaConfig } = require('../config/metaConfig');
+const { _clearClinicalContextCache } = require('../models/messageModel');
+const { _resetRegistry } = require('../services/assistantResolver');
+const { setPreprocessingHandler } = require('../services/preprocessingService');
+const { _resetDefaultInstance } = require('../core/NexusMessaging');
+
+function resetAll() {
+  _resetDefaultInstance();
+  _resetRegistry();
+  _resetLLMState();
+  setPreprocessingHandler(null);
+  _resetOverrides();
+  _resetMetaConfig();
+  _clearClinicalContextCache();
+}
+
+module.exports = { resetAll };

package/lib/config/llmConfig.js

@@ -51,6 +51,13 @@ const getAnthropicClient = () => {
   return state.anthropicClient;
 };
 
+const _resetState = () => {
+  state.anthropicClient = null;
+  state.openaiClient = null;
+  state.provider = null;
+  state.variant = process.env.VARIANT || 'assistants';
+};
+
 module.exports = {
   get openaiClient() { return state.openaiClient; },
   get providerInstance() { return state.provider; },
@@ -59,5 +66,6 @@ module.exports = {
   setOpenAIProvider,
   getOpenAIProvider,
   requireOpenAIProvider,
-  configureOpenAIProvider
+  configureOpenAIProvider,
+  _resetState
 };

package/lib/config/metaConfig.js

@@ -25,7 +25,12 @@ const setMetaConfig = ({ accessToken, wabaId, apiVersion }) => {
 
 const getMetaConfig = () => metaConfig;
 
+const _resetMetaConfig = () => {
+  metaConfig = { accessToken: null, wabaId: null, apiVersion: 'v21.0' };
+};
+
 module.exports = {
   setMetaConfig,
-  getMetaConfig
+  getMetaConfig,
+  _resetMetaConfig
 };

package/lib/config/runtimeConfig.js

@@ -11,5 +11,7 @@ function get(key, fallback = undefined) {
   return process.env[k] !== undefined ? process.env[k] : fallback;
 }
 
-module.exports = { set, get };
+function _resetOverrides() { overrides.clear(); }
+
+module.exports = { set, get, _resetOverrides };
 

package/lib/core/NexusMessaging.js

@@ -1,7 +1,6 @@
 const EventEmitter = require('events');
 
 const { airtable } = require('../config/airtableConfig');
-const runtimeConfig = require('../config/runtimeConfig');
 const llmConfigModule = require('../config/llmConfig');
 const { connect } = require('../config/mongoConfig');
 
@@ -11,7 +10,7 @@ const { Message, getMessageValues, insertMessage } = require('../models/messageM
 const { Thread } = require('../models/threadModel');
 
 const { ensureThreadExists } = require('../helpers/threadHelper');
-const { processTwilioMediaMessage } = require('../helpers/twilioMediaHelper');
+const { enrichMessageWithTwilioMedia } = require('../helpers/twilioMediaHelper');
 const { convertTwilioToInternalFormat } = require('../helpers/twilioHelper');
 
 const { createMessagingProvider } = require('../adapters/registry');
@@ -360,25 +359,15 @@ class NexusMessaging {
   async _ensureMediaPersistence(messageData) {
     try {
       const raw = messageData?.raw;
-      if (!raw || raw.__nexusMediaProcessed) return;
+      const result = await enrichMessageWithTwilioMedia(raw);
+      if (!result) return;
 
-      const numMedia = parseInt(raw.NumMedia || '0', 10);
-      if (numMedia <= 0 || !raw.MediaUrl0) return;
-
-      const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME');
-      if (!bucketName) return;
-
-      const mediaItems = await processTwilioMediaMessage(raw, bucketName);
-      if (!mediaItems?.length) return;
-
-      raw.__nexusMediaProcessed = true;
-      const [primary, ...rest] = mediaItems;
-      const mediaPayload = rest.length ? { ...primary, metadata: { ...primary.metadata, attachments: rest } } : primary;
+      const { mediaPayload, caption } = result;
 
       if (messageData.media == null) messageData.media = mediaPayload;
       if (messageData.fileUrl == null) messageData.fileUrl = mediaPayload.metadata?.presignedUrl;
       if (messageData.fileType == null) messageData.fileType = mediaPayload.mediaType;
-      if (messageData.caption == null) messageData.caption = primary.caption;
+      if (messageData.caption == null) messageData.caption = caption;
       if (messageData.body == null) messageData.body = messageData.caption;
       messageData.isMedia = true;
 
@@ -483,12 +472,15 @@ const sendScheduledMessage = async (scheduledMessage) => {
   return await requireDefaultInstance().sendScheduledMessage(scheduledMessage);
 };
 
-module.exports = { 
+const _resetDefaultInstance = () => { defaultInstance = null; };
+
+module.exports = {
   NexusMessaging,
   sendMessage,
   sendScheduledMessage,
   setDefaultInstance,
   getDefaultInstance,
   getProvider,
-  requireProvider
+  requireProvider,
+  _resetDefaultInstance
 };

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/twilioMediaHelper.js

@@ -1,5 +1,6 @@
 const { generatePresignedUrl } = require('../config/awsConfig');
 const { Monitoreo_ID } = require('../config/airtableConfig');
+const runtimeConfig = require('../config/runtimeConfig');
 
 const { validateMedia } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
@@ -120,6 +121,41 @@ async function processTwilioMediaMessage(twilioMessage, bucketName) {
   return mediaItems;
 }
 
+async function enrichMessageWithTwilioMedia(rawMessage) {
+  if (!rawMessage || rawMessage.__nexusMediaProcessed) return null;
+
+  const numMedia = parseInt(rawMessage.NumMedia || '0', 10);
+  if (numMedia <= 0 || !rawMessage.MediaUrl0) return null;
+
+  const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME');
+  if (!bucketName) {
+    logger.warn('[mediaEnrichment] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
+    return null;
+  }
+
+  const mediaItems = await processTwilioMediaMessage(rawMessage, bucketName);
+  if (!mediaItems || mediaItems.length === 0) {
+    logger.warn('[mediaEnrichment] Media processing returned no items');
+    return null;
+  }
+
+  const [primary, ...rest] = mediaItems;
+  const mediaPayload = rest.length > 0
+    ? { ...primary, metadata: { ...(primary.metadata || {}), attachments: rest } }
+    : primary;
+
+  rawMessage.__nexusMediaProcessed = true;
+
+  logger.info('[mediaEnrichment] Media processed successfully', {
+    primaryType: mediaPayload.mediaType,
+    mediaCount: mediaItems.length,
+    s3Key: mediaPayload.key
+  });
+
+  return { mediaPayload, caption: primary.caption };
+}
+
 module.exports = {
-  processTwilioMediaMessage
+  processTwilioMediaMessage,
+  enrichMessageWithTwilioMedia
 };

package/lib/index.d.ts

@@ -1,6 +1,4 @@
 declare module '@peopl-health/nexus' {
-  import mongoose from 'mongoose';
-
   // Core Types
   export interface MessageData {
     id?: string;
@@ -178,7 +176,6 @@ declare module '@peopl-health/nexus' {
     definition: typeof BaseAssistant | ((thread?: any) => any) | AssistantConfigDefinition
   ): any;
 
-  export function configureAssistantsLLM(client: any): void;
   export function overrideGetAssistantById(resolver: (assistantId: string, thread?: any) => any): void;
   export function configureAssistants(config: any): void;
   export function setPreprocessingHandler(
@@ -231,23 +228,42 @@ declare module '@peopl-health/nexus' {
     disconnect(): Promise<void>;
   }
 
-  export class AssistantManager {
-    constructor(config?: AssistantConfig);
-    setLLMClient(llmClient: any): void;
-    registerAssistants(assistantConfigs: Record<string, string>): void;
-    setHandlers(handlers: AssistantConfig['handlers']): void;
-    createThread(code: string, assistantId: string, initialMessages?: string[]): Promise<ThreadData>;
-    sendMessage(threadData: ThreadData, message: string, runOptions?: any): Promise<string | null>;
-    submitToolOutputs(threadId: string, runId: string, toolOutputs: any[]): Promise<any>;
-    addInstruction(threadData: ThreadData, instruction: string): Promise<string | null>;
-  }
-
   export class MessageParser {
     constructor(config?: ParserConfig);
     parseMessage(rawMessage: any): MessageData;
     updateConfig(newConfig: ParserConfig): void;
   }
 
+  // LLM Providers
+  export class OpenAIAssistantsProvider {
+    constructor(options?: { apiKey?: string; organization?: string; client?: any; defaultModels?: Record<string, string> });
+    getVariant(): string;
+    getClient(): any;
+    createConversation(options?: any): Promise<any>;
+    addMessage(options: { threadId: string; messages?: any[]; role?: string; content: string; metadata?: any }): Promise<any>;
+    listMessages(options?: any): Promise<any>;
+    getRunText(options?: any): Promise<string>;
+    executeRun(options: { thread: any; assistant: any; tools?: any[]; config?: any }): Promise<any>;
+    runConversation(options?: any): Promise<any>;
+    getRun(options: { threadId: string; runId: string }): Promise<any>;
+    submitToolOutputs(options: { threadId: string; runId: string; toolOutputs: any[] }): Promise<any>;
+    transcribeAudio(options?: any): Promise<any>;
+  }
+
+  export class OpenAIResponsesProvider {
+    constructor(options?: { apiKey?: string; organization?: string; client?: any; defaultModels?: Record<string, string>; conversationManager?: any });
+    getVariant(): string;
+    getClient(): any;
+    createConversation(options?: any): Promise<any>;
+    addMessage(options: { threadId: string; messages?: any[]; role?: string; content: string; metadata?: any }): Promise<any>;
+    listMessages(options?: any): Promise<any>;
+    executeRun(options: { thread: any; assistant: any; message?: string; tools?: any[]; config?: any }): Promise<any>;
+    runConversation(config?: any): Promise<any>;
+    transcribeAudio(options?: any): Promise<any>;
+  }
+
+  export function createLLMProvider(config?: { variant?: string; [key: string]: any }): OpenAIAssistantsProvider | OpenAIResponsesProvider;
+
   // Main Nexus Class
   export interface NexusConfig {
     messaging?: any;
@@ -270,18 +286,15 @@ declare module '@peopl-health/nexus' {
     sendMessage(messageData: MessageData): Promise<any>;
     sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
     processMessage(rawMessage: any): Promise<any>;
-    createAssistantThread(code: string, assistantId: string, initialMessages?: string[]): Promise<ThreadData>;
-    sendToAssistant(code: string, message: string, runOptions?: any): Promise<string | null>;
     isConnected(): boolean;
     disconnect(): Promise<void>;
     getMessaging(): NexusMessaging;
     getStorage(): MongoStorage | null;
-    getAssistantManager(): AssistantManager | null;
     getMessageParser(): MessageParser | null;
+    getLLMProvider(): OpenAIAssistantsProvider | OpenAIResponsesProvider | null;
   }
 
   // Utility Functions
-  export function createLogger(config?: any): any;
   export function formatCode(codeBase: string): string;
   export function calculateDelay(sendTime: string | Date, timeZone?: string): number;
   export function ensureWhatsAppFormat(phoneNumber: any): string | null;
@@ -291,49 +304,17 @@ declare module '@peopl-health/nexus' {
   export function extractTitle(message: any, mediaType: string): string | null;
   export function useMongoDBAuthState(uri: string, dbName: string, sessionId: string): Promise<any>;
 
-  // Models
-  export const Message: mongoose.Model<any>;
-  export const Thread: mongoose.Model<any>;
-  export function getMessageValues(message: any, content: string): any;
-  export function formatTimestamp(unixTimestamp: number): string;
-
-  // Module Exports
-  export const adapters: {
-    TwilioProvider: typeof TwilioProvider;
-    BaileysProvider: typeof BaileysProvider;
-  };
-
-  export const core: {
-    NexusMessaging: typeof NexusMessaging;
-    MessageProvider: typeof MessageProvider;
-  };
-
-  export const storage: {
-    MongoStorage: typeof MongoStorage;
-  };
-
-  export const utils: {
-    AssistantManager: typeof AssistantManager;
-    MessageParser: typeof MessageParser;
-    logger: any;
-    createLogger: typeof createLogger;
-    delay: typeof delay;
-    formatCode: typeof formatCode;
-    calculateDelay: typeof calculateDelay;
-    useMongoDBAuthState: typeof useMongoDBAuthState;
-    convertTwilioToInternalFormat: typeof convertTwilioToInternalFormat;
-    downloadMediaFromTwilio: typeof downloadMediaFromTwilio;
-    getMediaTypeFromContentType: typeof getMediaTypeFromContentType;
-    extractTitle: typeof extractTitle;
-    ensureWhatsAppFormat: typeof ensureWhatsAppFormat;
-  };
-
-  export const models: {
-    Message: typeof Message;
-    Thread: typeof Thread;
-    getMessageValues: typeof getMessageValues;
-    formatTimestamp: typeof formatTimestamp;
-  };
+  export const logger: any;
+  export function requestIdMiddleware(req: any, res: any, next: () => void): void;
+  export function getRequestId(): string | null;
+
+  export function setModelDatabases(mapping: Record<string, string>): void;
+  export function setModelDatabase(modelName: string, dbName: string): void;
+  export function getModelDatabase(modelName: string): string | null;
+
+  export const routes: any;
+  export function setupDefaultRoutes(app: any): void;
+  export function createRouter(routeDefinitions: Record<string, string>, controllers: Record<string, Function>): any;
 
   // Queue Adapters
   export interface QueueJobOptions {

package/lib/index.js

@@ -218,6 +218,7 @@ class Nexus {
 }
 
 const routes = require('./routes');
+const { resetAll } = require('./config/lifecycle');
 
 module.exports = {
   Nexus,
@@ -251,5 +252,7 @@ module.exports = {
   LocalQueueAdapter,
   RedisQueueAdapter,
   createQueueAdapter,
-  registerQueueAdapter
+  registerQueueAdapter,
+
+  resetAll
 };

package/lib/models/predictionMetricsModel.js

@@ -14,6 +14,12 @@ const predictionMetricsSchema = new mongoose.Schema({
   completed: { type: Boolean, default: true },
   error: { type: String, default: null },
   timing_breakdown: { type: Object, default: {} },
+  token_usage: {
+    input_tokens: { type: Number, default: 0 },
+    output_tokens: { type: Number, default: 0 },
+    total_tokens: { type: Number, default: 0 },
+    model: { type: String },
+  },
   source: { type: String, default: () => process.env.USER_DB_MONGO }
 }, { timestamps: true });
 
@@ -28,4 +34,22 @@ const getPredictionMetrics = () => {
   return db.models.PredictionMetrics || db.model('PredictionMetrics', predictionMetricsSchema);
 };
 
-module.exports = { getPredictionMetrics, predictionMetricsSchema };
+const getConversationTokenUsage = async (numero, since = null) => {
+  const Model = getPredictionMetrics();
+  const match = { numero, 'token_usage.total_tokens': { $gt: 0 } };
+  if (since) match.createdAt = { $gte: since };
+
+  const [result] = await Model.aggregate([
+    { $match: match },
+    { $group: {
+      _id: '$numero',
+      total_input_tokens: { $sum: '$token_usage.input_tokens' },
+      total_output_tokens: { $sum: '$token_usage.output_tokens' },
+      total_tokens: { $sum: '$token_usage.total_tokens' },
+      request_count: { $sum: 1 },
+    }}
+  ]);
+  return result || { _id: numero, total_input_tokens: 0, total_output_tokens: 0, total_tokens: 0, request_count: 0 };
+};
+
+module.exports = { getPredictionMetrics, getConversationTokenUsage, predictionMetricsSchema };

package/lib/models/threadModel.js

@@ -1,4 +1,7 @@
 const mongoose = require('mongoose');
+const runtimeConfig = require('../config/runtimeConfig');
+
+const VARIANT = runtimeConfig.get('VARIANT', 'assistants');
 
 const threadSchema = new mongoose.Schema({
   code: { type: String, required: true },
@@ -21,18 +24,15 @@ threadSchema.index({ thread_id: 1 });
 threadSchema.index({ conversation_id: 1 });
 
 threadSchema.methods.getConversationId = function() {
-  const variant = process.env.VARIANT || 'assistants';
-  return variant === 'assistants' ? this.thread_id : this.conversation_id;
+  return VARIANT === 'assistants' ? this.thread_id : this.conversation_id;
 };
 
 threadSchema.methods.getAssistantId = function() {
-  const variant = process.env.VARIANT || 'assistants';
-  return variant === 'assistants' ? this.assistant_id : this.prompt_id;
+  return VARIANT === 'assistants' ? this.assistant_id : this.prompt_id;
 };
 
 threadSchema.statics.setAssistantId = function(threadObj, assistantId) {
-  const variant = process.env.VARIANT || 'assistants';
-  if (variant === 'assistants') {
+  if (VARIANT === 'assistants') {
     threadObj.assistant_id = assistantId;
   } else {
     threadObj.prompt_id = assistantId;
@@ -41,8 +41,7 @@ threadSchema.statics.setAssistantId = function(threadObj, assistantId) {
 };
 
 threadSchema.statics.setConversationId = function(threadObj, conversationId) {
-  const variant = process.env.VARIANT || 'assistants';
-  if (variant === 'assistants') {
+  if (VARIANT === 'assistants') {
     threadObj.thread_id = conversationId;
   } else {
     threadObj.conversation_id = conversationId;

package/lib/observability/index.js

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

package/lib/observability/telemetry.js

@@ -17,6 +17,7 @@ class TelemetryManager {
   constructor() {
     this.sdk = null;
     this.isInitialized = false;
+    this.prometheusExporter = null;
   }
 
   async init(config = {}) {
@@ -74,14 +75,18 @@ class TelemetryManager {
           exportTimeoutMillis: isProd ? 5000 : 2000,
           scheduledDelayMillis: isProd ? 2000 : 500,
         }),
-        metricReader: new PrometheusExporter({ endpoint: prometheusEndpoint, port: prometheusPort }),
+        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: http://localhost:${prometheusPort}${prometheusEndpoint}`);
+      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);
@@ -109,5 +114,9 @@ const telemetryManager = new TelemetryManager();
 module.exports = {
   telemetryManager,
   initTelemetry: (config) => telemetryManager.init(config),
-  shutdownTelemetry: () => telemetryManager.shutdown()
+  shutdownTelemetry: () => telemetryManager.shutdown(),
+  getMetricsRequestHandler: () => {
+    if (!telemetryManager.prometheusExporter) return null;
+    return (req, res) => telemetryManager.prometheusExporter.getMetricsRequestHandler(req, res);
+  }
 };

package/lib/providers/OpenAIResponsesProvider.js

@@ -305,11 +305,23 @@ class OpenAIResponsesProvider {
 
     let totalRetries = 0;
     let allToolsExecuted = [];
+    const accumulatedUsage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    const addUsage = (usage) => {
+      if (!usage) return;
+      accumulatedUsage.input_tokens += usage.input_tokens || 0;
+      accumulatedUsage.output_tokens += usage.output_tokens || 0;
+      accumulatedUsage.total_tokens += usage.total_tokens || 0;
+    };
 
     const devRecord = await getRecordByFilter(Config_ID, 'responses', `{prompt_id} = "${assistantId}"`);
     let devContent = devRecord?.[0]?.content || '';
     if (promptVariables) devContent = devContent.replace(/\{\{(\w+)\}\}/g, (_, key) => promptVariables[key] ?? '');
 
+    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.`;
+    }
+
     const messages = (context || this._convertItemsToApiFormat(additionalMessages))
       .filter(item => item.type !== 'function_call' && item.type !== 'function_call_output');
     const input = [{ role: 'developer', content: devContent }, ...messages];
@@ -329,6 +341,7 @@ class OpenAIResponsesProvider {
 
     const { result: response, retries } = await makeAPICall(input);
     totalRetries += retries;
+    addUsage(response.usage);
     let finalResponse = response;
 
     if (assistant && response.output) {
@@ -349,6 +362,7 @@ class OpenAIResponsesProvider {
 
         const { result: followUp, retries: followUpRetries } = await makeAPICall(currentInput);
         totalRetries += followUpRetries;
+        addUsage(followUp.usage);
         finalResponse = followUp;
       }
     }
@@ -360,6 +374,7 @@ class OpenAIResponsesProvider {
       object: finalResponse.object || 'response',
       tools_executed: allToolsExecuted,
       retries: totalRetries,
+      usage: accumulatedUsage,
     };
   }
 

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -4,7 +4,7 @@ async function executeFunctionCall(assistant, call) {
   const startTime = Date.now();
   const name = call.name;
   const args = call.arguments ? JSON.parse(call.arguments) : {};
-  
+
   logger.info('[executeFunctionCall] Calling', { name, call_id: call.call_id });
   
   let result, success = true;

package/lib/routes/index.js

@@ -176,6 +176,12 @@ 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/assistantResolver.js

@@ -98,9 +98,16 @@ const getAssistantById = (assistant_id, thread) => {
   throw new Error(`Assistant with ID "${assistant_id}" not found`);
 };
 
+const _resetRegistry = () => {
+  assistantConfig = null;
+  assistantRegistry = {};
+  customGetAssistantById = null;
+};
+
 module.exports = {
   getAssistantById,
   configureAssistants,
   registerAssistant,
-  overrideGetAssistantById
+  overrideGetAssistantById,
+  _resetRegistry
 };

package/lib/services/assistantService.js

@@ -242,6 +242,8 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     const { output: rawOutput, completed, retries, predictionTimeMs, tools_executed } = runResult;
     const prompt = runResult.run?.prompt || null;
     const response_id = runResult.run?.id || null;
+    const usage = runResult.run?.usage || null;
+    const model = runResult.run?.model || null;
     
     const output = sanitizeOutput(rawOutput);
     if (rawOutput !== output) {
@@ -259,15 +261,28 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
       hasMedia: urls.length > 0,
       retries,
       totalMs: timings.total_ms,
-      toolsExecuted: tools_executed?.length || 0
+      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', { 
+      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,
@@ -275,8 +290,20 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
         prediction_time_ms: predictionTimeMs,
         retry_count: retries,
         completed: completed,
-        timing_breakdown: timings
+        timing_breakdown: timings,
+        token_usage: tokenUsage,
       }).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, response_id };

package/lib/storage/MongoStorage.js

@@ -7,7 +7,7 @@ const { Message, insertMessage } = require('../models/messageModel');
 const { Thread } = require('../models/threadModel');
 
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
-const { processTwilioMediaMessage } = require('../helpers/twilioMediaHelper'); 
+const { enrichMessageWithTwilioMedia } = require('../helpers/twilioMediaHelper');
 
 class MongoStorage {
   constructor(config) {
@@ -46,53 +46,22 @@ class MongoStorage {
   }
 
   async _enrichTwilioMedia(messageData = {}) {
-    logger.debug('[_enrichTwilioMedia] Input', { messageData });
     try {
       const rawMessage = messageData?.raw;
-      const numMedia = parseInt(rawMessage?.NumMedia || '0', 10);
-      if (!rawMessage?.From || numMedia <= 0 || !rawMessage.MediaUrl0) return messageData;
-
-      logger.info('[MongoStorage] Detected Twilio media message', {
-        from: rawMessage.From,
-        numMedia
-      });
-
-      const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME');
-      if (!bucketName) {
-        logger.warn('[MongoStorage] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
-        return messageData;
-      }
-
-      const mediaItems = await processTwilioMediaMessage(rawMessage, bucketName);
-      if (!mediaItems || mediaItems.length === 0) {
-        logger.warn('[MongoStorage] Media processing returned no items');
-        return messageData;
-      }
-
-      const [primary, ...rest] = mediaItems;
-      const mediaPayload = rest.length > 0
-        ? { ...primary, metadata: { ...(primary.metadata || {}), attachments: rest } }
-        : primary;
-
-      rawMessage.__nexusMediaProcessed = true;
-
-      logger.info('[MongoStorage] Media processed successfully', {
-        primaryType: mediaPayload.mediaType,
-        mediaCount: mediaItems.length,
-        s3Key: mediaPayload.key
-      });
-
-      const result = {
+      if (!rawMessage?.From) return messageData;
+
+      const result = await enrichMessageWithTwilioMedia(rawMessage);
+      if (!result) return messageData;
+
+      return {
         ...messageData,
-        media: mediaPayload,
+        media: result.mediaPayload,
         fileUrl: undefined,
-        fileType: mediaPayload.mediaType,
+        fileType: result.mediaPayload.mediaType,
         isMedia: true,
-        body: messageData.body || primary.caption,
-        caption: primary.caption
+        body: messageData.body || result.caption,
+        caption: result.caption
       };
-      logger.debug('[_enrichTwilioMedia] Output', { result });
-      return result;
     } catch (error) {
       logger.error('[MongoStorage] Failed to enrich Twilio media message', { error });
       return messageData;
@@ -100,7 +69,6 @@ class MongoStorage {
   }
 
   buildMessageValues(messageData = {}) {
-    logger.debug('[buildMessageValues] Input', { messageData });
     const now = new Date();
     const numero = ensureWhatsAppFormat(messageData.code || messageData.from || '');
     const isMedia = messageData.isMedia === true || (messageData.fileType && messageData.fileType !== 'text');
@@ -128,7 +96,6 @@ class MongoStorage {
       response_id: messageData.response_id || null,
       statusInfo: messageData.statusInfo || null
     };
-    logger.debug('[buildMessageValues] Output', { values });
     return values;
   }
 

package/package.json

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