@peopl-health/nexus 4.4.4 → 4.5.21

package/lib/providers/NerClient.js

@@ -0,0 +1,43 @@
+const axios = require('axios');
+
+const { logger } = require('../utils/logger');
+
+const { detectStructured, personaFallback, mergeSpans } = require('../helpers/nerHelper');
+
+class NerClient {
+  constructor({ nerUrl, nerApiKey, nerTimeoutMs } = {}) {
+    this.url = nerUrl || null;
+    this.apiKey = nerApiKey || null;
+    this.timeout = nerTimeoutMs || 3000;
+
+    if (this.url && !this.apiKey) {
+      logger.warn('[NerClient] NER URL configured without an API key');
+    }
+  }
+
+  async detectEntities(text) {
+    if (typeof text !== 'string' || !text.trim()) return [];
+
+    const structured = detectStructured(text);
+
+    if (!this.url) {
+      logger.debug('[NerClient] No NER endpoint configured, using regex fallback');
+      return mergeSpans(personaFallback(text), structured);
+    }
+
+    try {
+      const headers = { 'Content-Type': 'application/json' };
+      if (this.apiKey) headers['x-api-key'] = this.apiKey;
+
+      // same-length replacement keeps span offsets valid against original text
+      const cleaned = text.replace(/[?!]/g, ' ');
+      const { data } = await axios.post(this.url, { text: cleaned }, { headers, timeout: this.timeout });
+      return mergeSpans(data.entities || [], structured);
+    } catch (err) {
+      logger.warn('[NerClient] Lambda call failed, falling back to regex', { error: err.message });
+      return mergeSpans(personaFallback(text), structured);
+    }
+  }
+}
+
+module.exports = { NerClient };

package/lib/providers/OpenAIResponsesProvider.js

@@ -7,10 +7,10 @@ const { getCurrentMexicoDateTime } = require('../utils/dateUtils');
 
 const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 
-const { getLastNMessages } = require('../helpers/messageHelper');
-
 const { composePrompt, resolveTools } = require('../services/promptComposerService');
 const { getToolSchemas: getRegistrySchemas } = require('../services/toolRegistryService');
+const { getMessages } = require('../services/messageService');
+
 const { logBugReportToAirtable } = require('../controllers/bugReportController');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
@@ -248,10 +248,12 @@ class OpenAIResponsesProvider {
         }
       });
 
-      const lastMessage = await getLastNMessages(thread.code, 1);
+      const [lastMessage] = await getMessages({ numero: thread.code }, { sort: { createdAt: -1 }, limit: 1 });
+      const phiProcessor = config.phiProcessor;
+      const maskedCode = phiProcessor ? phiProcessor.hashCode(thread.code) : thread.code;
       const metadata = {
-        numero: thread.code,
-        message_id: message?.message_id || lastMessage[0]?.message_id || null
+        numero: maskedCode,
+        message_id: message?.message_id || lastMessage?.message_id || null
       };
 
       logger.info('[executeRun] Context built', { conversationId, messageCount: context?.length || 0 });
@@ -342,7 +344,7 @@ class OpenAIResponsesProvider {
       threadId, assistantId, presetId = null, presetVersion = null, additionalMessages = [], context = null,
       instructions = null, additionalInstructions = null, metadata = {},
       assistant, promptVersion = null, promptVariables = null,
-      toolChoice = 'auto', prePromptResult = null
+      toolChoice = 'auto', prePromptResult = null, phiProcessor = null
     } = config;
 
     let totalRetries = 0;
@@ -466,7 +468,7 @@ class OpenAIResponsesProvider {
         const functionCalls = finalResponse.output.filter(item => item.type === 'function_call');
         if (!functionCalls.length) break;
 
-        const { outputs, toolsExecuted } = await handleFunctionCalls(functionCalls, assistant);
+        const { outputs, toolsExecuted } = await handleFunctionCalls(functionCalls, assistant, phiProcessor);
 
         currentInput.push(...finalResponse.output, ...outputs);
         allToolsExecuted.push(...toolsExecuted);

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -1,32 +1,49 @@
 const { logger } = require('../utils/logger');
+const { safeParse } = require('../utils/jsonUtils');
+
 const { hasTool, executeTool: registryExecuteTool } = require('../services/toolRegistryService');
 
-async function executeFunctionCall(assistant, call) {
+async function executeFunctionCall(assistant, call, phiProcessor) {
   const startTime = Date.now();
   const name = call.name;
-  const args = call.arguments ? JSON.parse(call.arguments) : {};
+  const code = assistant?.thread?.code;
+  const argsStr = call.arguments || '{}';
+  const args = safeParse(argsStr);
+  let decodedArgs = args;
+  try {
+    decodedArgs = JSON.parse(await phiProcessor?.decodeBody(argsStr, code) ?? argsStr);
+  } catch (e) {
+    logger.warn('[executeFunctionCall] arg decode produced invalid JSON, falling back to original args', { name, error: e.message });
+  }
 
   logger.info('[executeFunctionCall] Calling', { name, call_id: call.call_id });
 
   let result, success = true;
   try {
     if (hasTool(name)) {
-      result = await registryExecuteTool(name, args, assistant?.thread);
+      result = await registryExecuteTool(name, decodedArgs, assistant?.thread);
     } else {
-      result = await assistant.executeTool(name, args);
+      result = await assistant.executeTool(name, decodedArgs);
     }
     logger.info('[executeFunctionCall] Completed', { name, call_id: call.call_id, source: hasTool(name) ? 'registry' : 'assistant', duration_ms: Date.now() - startTime });
   } catch (error) {
-    result = { error: error?.message || 'Tool execution failed' };
+    result = JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' });
     success = false;
     logger.error('[executeFunctionCall] Failed', { name, call_id: call.call_id, error: error?.message });
   }
-  
+
+  try {
+    result = await phiProcessor?.encodeBody(result, code) ?? result;
+  } catch (e) {
+    logger.error('[executeFunctionCall] PHI encoding failed, returning safe error', { name, call_id: call.call_id, error: e.message });
+    result = JSON.stringify({ success: false, error: 'PHI encoding failed' });
+  }
+
   return {
     functionOutput: {
       type: 'function_call_output',
       call_id: call.call_id,
-      output: success && typeof result === 'string' ? result : JSON.stringify(success ? result : { success: false, error: result.error })
+      output: result,
     },
     toolData: {
       tool_name: name,
@@ -40,14 +57,14 @@ async function executeFunctionCall(assistant, call) {
   };
 }
 
-async function handleFunctionCalls(functionCalls, assistant) {
+async function handleFunctionCalls(functionCalls, assistant, phiProcessor) {
   if (!functionCalls?.length) return { outputs: [], toolsExecuted: [] };
 
   const outputs = [];
   const toolsExecuted = [];
 
   for (const call of functionCalls) {
-    const { functionOutput, toolData } = await executeFunctionCall(assistant, call);
+    const { functionOutput, toolData } = await executeFunctionCall(assistant, call, phiProcessor);
     outputs.push(functionOutput);
     toolsExecuted.push(toolData);
   }

package/lib/services/assistantService.js

@@ -5,15 +5,16 @@ const { logger } = require('../utils/logger');
 const { withTracing } = require('../utils/tracingDecorator.js');
 
 const { Thread } = require('../models/threadModel.js');
-const { insertMessage } = require('../models/messageModel');
 
 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 { cleanupFiles } = require('../helpers/filesHelper.js');
 
 const { createLLMProvider } = require('../providers/createLLMProvider');
+
+const { getMessages, insertMessage } = require('../services/messageService');
+
 const { getAssistantById } = require('./assistantResolver');
 
 const createAssistantCore = async (code, assistant_id, _messages = [], force = false) => {
@@ -127,14 +128,14 @@ const preProcessMessagesCore = async (code, message_ = null, thread) => {
   try {
     const messagesStart = Date.now();
     const beforeCheckpoint = message_?.createdAt ?? null;
-    const lastMessage = await getLastNMessages(code, 1, beforeCheckpoint, {
-      query: { from_me: false }
-    });
+    const query = { numero: code, from_me: false };
+    if (beforeCheckpoint) query.createdAt = { $lte: beforeCheckpoint };
+    const lastMessage = await getMessages(query, { sort: { createdAt: -1 }, limit: 1 });
     timings.get_messages_ms = Date.now() - messagesStart;
 
     if (!lastMessage || lastMessage.length === 0) {
       logger.info('[preProcessMessages] No relevant data found for this assistant.');
-      return { shouldProcess: false, messages: null, timings };
+      return { shouldProcess: false, messages: null, timings, pendingMediaUpdates: [] };
     }
 
     const provider = createLLMProvider({ variant: getProviderVariant() });
@@ -160,24 +161,32 @@ const preProcessMessagesCore = async (code, message_ = null, thread) => {
     const patientMsg = processResults.some(r => r.isPatient);
     const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
 
-    await Promise.all(processResults.map(r => {
+    const pendingMediaUpdates = processResults.reduce((acc, r) => {
       const processedContent = r.messages && r.messages.length > 0
         ? r.messages
           .filter(msg => msg.content.text !== r.reply?.body)
           .map(msg => msg.content.text)
           .join(' ')
         : null;
-      return r.reply ? storeProcessedContent(r.reply, thread, processedContent) : null;
-    }).filter(Boolean));
+      if (!r.reply || !processedContent || !r.reply.media) return acc;
+      acc.push({
+        message_id: r.reply.message_id,
+        media: r.reply.media,
+        processedContent,
+        assistantId: thread.getAssistantId(),
+        threadId: thread.getConversationId(),
+      });
+      return acc;
+    }, []);
 
     await cleanupFiles(allTempFiles);
 
     if (!patientMsg || thread.stopped) {
       logger.info('[preProcessMessages] Skipping AI processing', { patientMsg, stopped: thread.stopped, code });
-      return { shouldProcess: false, messages: null, timings };
+      return { shouldProcess: false, messages: null, timings, pendingMediaUpdates };
     }
 
-    return { shouldProcess: true, messages: lastMessage, timings };
+    return { shouldProcess: true, messages: lastMessage, timings, pendingMediaUpdates };
   } catch (error) {
     logger.error('[preProcessMessages] Error', { error: error.message, code });
     throw error;

package/lib/services/dashboardService.js

@@ -1,11 +1,11 @@
 const { logger } = require('../utils/logger');
 const MapCache = require('../utils/MapCache');
 
-const { Message } = require('../models/messageModel');
-
 const { fetchBoxesFromAirtable, fetchDetailsFromAirtable, attachPreview } = require('../helpers/dashboardHelper');
 const { getMexicoDateRange, buildPatientMessagesPipeline, buildToolDistributionPipeline, mergeTrendData } = require('../helpers/trendHelper');
 
+const { aggregateMessages } = require('./messageService');
+
 const boxCache = new MapCache({ maxSize: 100 });
 const detailCache = new MapCache({ maxSize: 100 });
 
@@ -72,10 +72,10 @@ async function getDailyTrend(days) {
   const { startDate, today } = getMexicoDateRange(days);
 
   const patientPipeline = buildPatientMessagesPipeline(startDate);
-  const patientData = await Message.aggregate(patientPipeline, { allowDiskUse: true });
+  const patientData = await aggregateMessages(patientPipeline, { allowDiskUse: true });
 
   const toolPipeline = buildToolDistributionPipeline(startDate);
-  const toolData = await Message.aggregate(toolPipeline, { allowDiskUse: true });
+  const toolData = await aggregateMessages(toolPipeline, { allowDiskUse: true });
 
   const dailyData = mergeTrendData(patientData, toolData, today, days);
 

package/lib/services/globalEntityService.js

@@ -0,0 +1,59 @@
+const { logger } = require('../utils/logger');
+const MapCache = require('../utils/MapCache');
+const { normalize } = require('../utils/tokenMapUtils');
+
+const { getGlobalEntityMap } = require('../models/globalEntityMapModel');
+
+const RELOAD_TTL_MS = 5 * 60 * 1000;
+const CACHE_KEY = 'all';
+
+const cache = new MapCache({ maxSize: 1, ttl: RELOAD_TTL_MS });
+
+const loadAll = async () => {
+  const byNormalized = new Map();
+  const byToken = new Map();
+  const docs = await getGlobalEntityMap().find({}).lean();
+  for (const doc of docs) {
+    for (const [k, token] of Object.entries(doc.encode || {})) {
+      if (byNormalized.has(k)) {
+        logger.error('[loadAll] Normalized key collision', { key: k, existing: byNormalized.get(k).token, incoming: token, category: doc.category });
+        continue;
+      }
+      byNormalized.set(k, { token, category: doc.category });
+    }
+    for (const [token, plaintext] of Object.entries(doc.decode || {})) {
+      byToken.set(token, plaintext);
+    }
+  }
+  cache.set(CACHE_KEY, { byNormalized, byToken });
+  logger.debug('[loadAll] Loaded global entities', { count: byNormalized.size });
+};
+
+const getIndexes = async () => {
+  const hit = cache.get(CACHE_KEY);
+  if (hit) return hit;
+  await loadAll();
+  return cache.get(CACHE_KEY);
+};
+
+const lookupGlobal = async (plaintext) => {
+  const key = normalize(plaintext);
+  if (!key) return null;
+  const { byNormalized } = await getIndexes();
+  const entry = byNormalized.get(key);
+  if (!entry) return null;
+  return { token: entry.token, category: entry.category };
+};
+
+const lookupGlobalToken = async (token) => {
+  if (!token) return null;
+  const { byToken } = await getIndexes();
+  const plaintext = byToken.get(token);
+  return plaintext !== undefined ? plaintext : null;
+};
+
+module.exports = {
+  lookupGlobal,
+  lookupGlobalToken,
+  loadAll,
+};

package/lib/services/messageService.js

@@ -0,0 +1,107 @@
+const { Monitoreo_ID } = require('../config/airtableConfig');
+
+const { logger } = require('../utils/logger');
+
+const { Message } = require('../models/messageModel');
+const { Thread } = require('../models/threadModel');
+
+const { getClinicalContext } = require('../helpers/patientInformationHelper');
+
+const { updateRecordByFilter } = require('../services/airtableService');
+
+const INTERNAL_ORIGINS = new Set(['system', 'instruction']);
+
+async function getMessages(query, options = {}) {
+  let cursor = Message.find(query);
+  if (options.select) cursor = cursor.select(options.select);
+  if (options.sort) cursor = cursor.sort(options.sort);
+  if (options.skip != null) cursor = cursor.skip(options.skip);
+  if (options.limit != null) cursor = cursor.limit(options.limit);
+  return cursor.lean();
+}
+
+async function countMessages(query) {
+  return Message.countDocuments(query);
+}
+
+async function aggregateMessages(pipeline, options = {}) {
+  return Message.aggregate(pipeline, options);
+}
+
+async function insertMessage(values) {
+  try {
+    if (!values.clinical_context) {
+      const { clinicalContext } = await getClinicalContext(values.numero);
+      values.clinical_context = clinicalContext;
+    }
+    const messageData = Object.fromEntries(
+      Object.entries(values).filter(([, v]) => v !== undefined)
+    );
+
+    if (!Array.isArray(messageData.tools_executed)) {
+      messageData.tools_executed = [];
+    }
+
+    let doc;
+    let isNew;
+    if (values.message_id == null) {
+      doc = await Message.create(messageData);
+      isNew = true;
+    } else {
+      const result = await Message.findOneAndUpdate(
+        { message_id: values.message_id },
+        { $setOnInsert: messageData },
+        { upsert: true, new: true, setDefaultsOnInsert: true, includeResultMetadata: true }
+      );
+      doc = result.value;
+      isNew = !result.lastErrorObject?.updatedExisting;
+    }
+
+    if (isNew && values.numero && !INTERNAL_ORIGINS.has(values.origin)) {
+      Thread.findOneAndUpdate(
+        { code: values.numero },
+        {
+          $set: {
+            lastMessageAt: new Date(),
+            lastMessageBody: values.body || '',
+            lastMessageFromMe: !!values.from_me,
+            lastMessageMedia: values.media || null
+          },
+          $inc: {
+            messageCount: 1,
+            ...(!values.from_me ? { unreadCount: 1 } : {})
+          }
+        },
+        { upsert: true, setDefaultsOnInsert: true }
+      ).catch(err => logger.error('[MongoStorage] Failed to denormalize thread', { numero: values.numero, error: err.message }));
+    }
+
+    updateRecordByFilter(Monitoreo_ID, 'message_monitor', `{whatsapp_id} = "${values.numero}"`, {
+      ...(values.from_me ? { last_message_bot: values.body } : { last_message_patient: values.body, read: false }),
+      ...(values.from_me ? { last_message_bot_time: doc.createdAt.toISOString() } : { last_message_patient_time: doc.createdAt.toISOString() })
+    }, values.numero).catch(err => logger.error('[MongoStorage] Failed to update message_monitor table', { numero: values.numero, error: err.message }));
+
+    logger.info('[MongoStorage] Message inserted or updated successfully');
+    return { isNew, doc };
+  } catch (err) {
+    logger.error('[MongoStorage] Error inserting message', { error: err.message, stack: err.stack });
+    throw err;
+  }
+}
+
+async function updateMessage(filter, update) {
+  try {
+    await Message.updateMany(filter, update);
+  } catch (err) {
+    logger.error('[messageService] updateMessage failed', { error: err.message });
+    throw err;
+  }
+}
+
+module.exports = {
+  getMessages,
+  countMessages,
+  aggregateMessages,
+  insertMessage,
+  updateMessage,
+};

package/lib/services/metaService.js

@@ -5,16 +5,8 @@ const { getMetaConfig } = require('../config/metaConfig');
 const { logger } = require('../utils/logger');
 const { jsonStringifyWithUnicodeEscapes } = require('../utils/jsonUtils');
 
-const requireConfig = () => {
-  const config = getMetaConfig();
-  if (!config.accessToken || !config.wabaId) {
-    throw new Error('Meta API not configured. Call setMetaConfig() first with accessToken and wabaId.');
-  }
-  return config;
-};
-
 const getApiUrl = (path) => {
-  const config = requireConfig();
+  const config = getMetaConfig();
   return `https://graph.facebook.com/${config.apiVersion}/${path}`;
 };
 
@@ -27,7 +19,7 @@ const errorResult = (error) => ({
 });
 
 async function createFlowInMeta(flowJSON, name, category = 'OTHER') {
-  const config = requireConfig();
+  const config = getMetaConfig();
   const categories = Array.isArray(category) ? category : [category];
 
   logger.info('[createFlowInMeta] Creating', { name, categories });
@@ -58,7 +50,7 @@ async function createFlowInMeta(flowJSON, name, category = 'OTHER') {
 }
 
 async function setFlowEndpoint(flowId, endpointUri, applicationId) {
-  const config = requireConfig();
+  const config = getMetaConfig();
 
   try {
     const response = await axios.post(getApiUrl(flowId), {
@@ -78,7 +70,7 @@ async function setFlowEndpoint(flowId, endpointUri, applicationId) {
 }
 
 async function getFlowFromMeta(flowId) {
-  const config = requireConfig();
+  const config = getMetaConfig();
 
   try {
     const response = await axios.get(getApiUrl(flowId), {
@@ -101,7 +93,7 @@ async function getFlowFromMeta(flowId) {
 }
 
 async function publishFlowInMeta(flowId) {
-  const config = requireConfig();
+  const config = getMetaConfig();
 
   try {
     const current = await getFlowFromMeta(flowId);

package/lib/services/patientService.js

@@ -3,11 +3,12 @@ const { Estado_General_ID } = require('../config/airtableConfig');
 const { logger } = require('../utils/logger');
 
 const { Thread } = require('../models/threadModel');
-const { Message } = require('../models/messageModel');
 const { getPatientAuditLog } = require('../models/patientAuditLogModel');
 
 const { getRecordByFilter, updateRecordByFilter } = require('../services/airtableService');
 
+const { updateMessage } = require('../services/messageService');
+
 const getPatientInformation = async (id) => {
   const records = await getRecordByFilter(Estado_General_ID, 'estado_general', `{whatsapp_id}='${id}'`);
   if (!records || records.length === 0) return null;
@@ -83,7 +84,7 @@ const updatePatientInformation = async (code, fields, auditContext = {}) => {
   const nameUpdated = fields.updt_name && !failedFields.some(f => f.key === 'updt_name');
   if (nameUpdated) {
     await Thread.updateOne({ code }, { nombre: fields.updt_name });
-    await Message.updateMany({ numero: code, from_me: false }, { nombre_whatsapp: fields.updt_name });
+    await updateMessage({ numero: code, from_me: false }, { $set: { nombre_whatsapp: fields.updt_name } });
   }
 
   const status = failedFields.length > 0 ? 'partial' : 'success';

package/lib/services/tokenMapService.js

@@ -0,0 +1,100 @@
+const { logger } = require('../utils/logger');
+const MapCache = require('../utils/MapCache');
+const { normalize } = require('../utils/tokenMapUtils');
+
+const { getTokenMap, PHI_CATEGORIES } = require('../models/tokenMapModel');
+
+const tokenCache = new MapCache({ maxSize: 500 });
+
+const getSubmap = async (code) => {
+  const cached = tokenCache.get(code);
+  if (cached) return cached;
+
+  const doc = await getTokenMap().findOne({ code }).lean();
+  const submap = {
+    encode: new Map(Object.entries(doc?.encode || {})),
+    decode: new Map(Object.entries(doc?.decode || {})),
+  };
+  tokenCache.set(code, submap);
+  return submap;
+};
+
+const allocateToken = async (code, plaintext, category, normalized, submap) => {
+  const counter = submap.encode.size + 1;
+  const token = `<<${category}_${counter}>>`;
+
+  submap.encode.set(normalized, token);
+  submap.decode.set(token, plaintext);
+
+  const res = await getTokenMap().updateOne(
+    { code },
+    {
+      $set: {
+        encode: Object.fromEntries(submap.encode),
+        decode: Object.fromEntries(submap.decode),
+      }
+    },
+    { upsert: true }
+  );
+  if (!res || (res.modifiedCount === 0 && !res.upsertedCount)) {
+    logger.error('[allocateToken] Mapping write modified 0 docs', { code, category, token });
+    throw new Error(`[allocateToken] Mapping write modified 0 docs for token ${token}`);
+  }
+  return token;
+};
+
+const encode = async (code, plaintext, category) => {
+  if (!PHI_CATEGORIES.includes(category)) {
+    throw new Error(`[encode] Unknown category: ${category}`);
+  }
+  if (plaintext === null || plaintext === undefined || String(plaintext).length === 0) {
+    return '';
+  }
+
+  const normalized = normalize(plaintext);
+  if (normalized === '') return '';
+
+  const submap = await getSubmap(code);
+  const existing = submap.encode.get(normalized);
+  if (existing) return existing;
+
+  const token = await allocateToken(code, String(plaintext), category, normalized, submap);
+  logger.debug('[encode] Allocated', { code, category, token });
+  return token;
+};
+
+const decode = async (code, token) => {
+  if (!token) return token;
+  const submap = await getSubmap(code);
+  const plaintext = submap.decode.get(token);
+  return plaintext !== undefined ? plaintext : token;
+};
+
+const encodeMany = async (code, items) => {
+  const tokens = [];
+  for (const { plaintext, category } of items || []) {
+    tokens.push(await encode(code, plaintext, category));
+  }
+  return tokens;
+};
+
+const decodeMany = async (code, tokens) => {
+  const out = [];
+  for (const token of tokens || []) {
+    out.push(await decode(code, token));
+  }
+  return out;
+};
+
+const reset = async (code) => {
+  await getTokenMap().deleteOne({ code });
+  tokenCache.delete(code);
+};
+
+module.exports = {
+  encode,
+  decode,
+  encodeMany,
+  decodeMany,
+  reset,
+};

package/lib/storage/MongoStorage.js

@@ -4,11 +4,13 @@ const runtimeConfig = require('../config/runtimeConfig');
 const { logger } = require('../utils/logger');
 const { createEvent, safeEmit } = require('../utils/eventUtils');
 
-const { Message, insertMessage } = require('../models/messageModel');
+const { Message } = require('../models/messageModel');
 const { Thread } = require('../models/threadModel');
 
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 
+const { getMessages, insertMessage } = require('../services/messageService');
+
 const { getEventBus: getStatusEventBus } = require('../core/NexusMessaging');
 
 class MongoStorage {
@@ -39,8 +41,8 @@ class MongoStorage {
       const values = this.buildMessageValues(messageData);
       const { doc } = await insertMessage(values);
       logger.info('[MongoStorage] Message stored');
-      this._emitMessageNew(doc, messageData.from, messageData.frontendId);
-      return values;
+      if (!messageData.silent) this._emitMessageNew(doc, messageData.from, messageData.frontendId);
+      return doc;
     } catch (error) {
       logger.error('Error saving message', { error });
       throw error;
@@ -53,7 +55,7 @@ class MongoStorage {
       statusInfo: { status: 'queued', updatedAt: new Date() }
     });
     const { doc } = await insertMessage(values);
-    this._emitMessageNew(doc, messageData.from, messageData.frontendId, 'queued');
+    if (!messageData.silent) this._emitMessageNew(doc, messageData.from, messageData.frontendId, 'queued');
     return doc;
   }
 
@@ -101,7 +103,7 @@ class MongoStorage {
     const fromMe = messageData.fromMe !== undefined ? messageData.fromMe : true;
 
     const values = {
-      nombre_whatsapp: fromMe ? runtimeConfig.get('USER_DB_MONGO') : messageData.pushName,
+      nombre_whatsapp: messageData.pushName ?? (fromMe ? runtimeConfig.get('USER_DB_MONGO') : null),
       numero: ensureWhatsAppFormat(messageData.code),
       body: messageData.body || '',
       processed: messageData.processed || false,
@@ -114,6 +116,7 @@ class MongoStorage {
       template_variables: messageData.variables ? JSON.stringify(messageData.variables) : null,
       raw: messageData.raw || null,
       origin: messageData.origin || 'whatsapp_platform',
+      assistant_id: messageData.assistantId || null,
       tools_executed: messageData.tools_executed,
       prompt: messageData.prompt || null,
       preset: messageData.preset || null,
@@ -126,15 +129,7 @@ class MongoStorage {
   }
 
   async getMessages(numero, limit = 50) {
-    try {
-      return await this.schemas.Message
-        .find({ numero })
-        .sort({ createdAt: -1 })
-        .limit(limit);
-    } catch (error) {
-      logger.error('Error getting messages', { error });
-      throw error;
-    }
+    return getMessages({ numero }, { sort: { createdAt: -1 }, limit });
   }
 
   async getThread(code) {