@peopl-health/nexus 4.4.5 → 4.5.21

package/lib/eval/EvalProvider.js

@@ -11,6 +11,7 @@ const { handleFunctionCalls } = require('../providers/OpenAIResponsesProviderToo
 const { composePrompt, resolveTools } = require('../services/promptComposerService');
 const { getToolSchemas: getRegistrySchemas } = require('../services/toolRegistryService');
 const { getAssistantById } = require('../services/assistantResolver');
+const { PhiProcessor } = require('../core/PhiProcessor');
 
 const MAX_FUNCTION_ROUNDS = parseInt(process.env.MAX_FUNCTION_ROUNDS || '5', 10);
 
@@ -47,6 +48,10 @@ class EvalProvider {
       client: this.client,
       defaultModels: { responseModel: this.model },
     });
+    this.phiProcessor = new PhiProcessor({
+      encode: config.phi?.encode || false,
+      ner: config.phi?.ner || null,
+    });
   }
 
   id() {
@@ -254,7 +259,7 @@ class EvalProvider {
       const calls = finalResponse.output.filter(item => item.type === 'function_call');
       if (!calls.length) break;
 
-      const { outputs, toolsExecuted } = await handleFunctionCalls(calls, assistant);
+      const { outputs, toolsExecuted } = await handleFunctionCalls(calls, assistant, this.phiProcessor);
       currentInput.push(...finalResponse.output, ...outputs);
       allToolsExecuted.push(...toolsExecuted);
 

package/lib/helpers/baileysHelper.js

@@ -2,10 +2,12 @@ const { downloadMediaMessage } = require('baileys');
 
 const { logger } = require('../utils/logger');
 
-const { insertMessage, getMessageValues } = require('../models/messageModel.js');
+const { getMessageValues } = require('../models/messageModel.js');
 
 const { uploadMediaToS3 } = require('../helpers/mediaHelper.js');
 
+const { insertMessage } = require('../services/messageService');
+
 async function processMessage(message, messageType) {
   try {
     const { content } = extractMessageContent(message, messageType);

package/lib/helpers/conversationWindowHelper.js

@@ -1,14 +1,14 @@
-const { Message } = require('../models/messageModel');
+const { getMessages } = require('../services/messageService');
 
 const WINDOW_MS = 24 * 60 * 60 * 1000;
 
 async function isWithin24HourWindow(code) {
   if (!code) return false;
   const cutoff = new Date(Date.now() - WINDOW_MS);
-  const recent = await Message.findOne(
+  const [recent] = await getMessages(
     { numero: code, from_me: false, createdAt: { $gte: cutoff } },
-    '_id'
-  ).lean();
+    { select: '_id', limit: 1 }
+  );
   return !!recent;
 }
 

package/lib/helpers/deliveryAttemptHelper.js

@@ -3,6 +3,8 @@ const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { DeliveryAttempt, DELIVERY_ATTEMPT_TERMINAL_STATUSES } = require('../models/deliveryAttemptModel');
 
+const { getMessages } = require('../services/messageService');
+
 async function recordDeliveryAttempt({
   messageData = null, messageId = null, twilioResult = null, kind, body = null,
   errorSource = null, errorCode = null, errorMessage = null
@@ -13,7 +15,7 @@ async function recordDeliveryAttempt({
   let targetId = messageId;
   if (!targetId) {
     if (!sid) return null;
-    const msgDoc = await Message.findOne({ message_id: sid }, '_id').lean();
+    const [msgDoc] = await getMessages({ message_id: sid }, { select: '_id', limit: 1 });
     if (!msgDoc) {
       logger.warn('[deliveryAttemptHelper] Message not found for SID; skipping attempt record', { twilioSid: sid });
       return null;

package/lib/helpers/filesHelper.js

@@ -8,7 +8,7 @@ const { downloadFileFromS3 } = require('../config/awsConfig.js');
 const { sanitizeFilename } = require('../utils/sanitizerUtils.js');
 const { logger } = require('../utils/logger');
 
-const { Message } = require('../models/messageModel.js');
+const { getMessages } = require('../services/messageService');
 
 async function convertPdfToImages(pdfName, existingPdfPath = null) {
   const outputDir = path.join(__dirname, 'assets', 'tmp');
@@ -89,10 +89,7 @@ const cleanupFiles = async (files) => {
 
 async function downloadMediaAndCreateFile(code, reply) {
   try {
-    const resultMedia = await Message.findOne({
-      message_id: reply.message_id,
-      media: { $ne: null }
-    });
+    const [resultMedia] = await getMessages({ message_id: reply.message_id, media: { $ne: null } }, { limit: 1 });
 
     const { bucketName, key } = resultMedia?.media || {};
     if (!bucketName || !key) return [];

package/lib/helpers/messageHelper.js

@@ -1,67 +1,8 @@
 const moment = require('moment-timezone');
 
 const { logger } = require('../utils/logger');
-const { maskSensitiveValue } = require('../utils/sanitizerUtils');
 
-const { Message } = require('../models/messageModel.js');
-
-const storeProcessedContent = async (reply, thread, processedContent) => {
-  if (!processedContent || !reply.media) return;
-
-  await Message.updateOne(
-    { message_id: reply.message_id },
-    { $set: {
-      assistant_id: thread.getAssistantId(),
-      thread_id: thread.getConversationId(),
-      media: { 
-        ...reply.media, 
-        metadata: { 
-          ...(reply.media.metadata || {}), 
-          processedContent 
-        } 
-      }
-    }}
-  );
-};
-
-async function getLastMessages(code) {
-  try {
-    const messages = await Message.find({
-      processed: false, numero: code,
-      $or: [{ origin: 'patient' }, { origin: 'whatsapp_platform' }]
-    }).sort({ createdAt: 1 });
-
-    if (!messages?.length) {
-      logger.info('[getLastMessages] No unprocessed messages', { code: maskSensitiveValue(code) });
-      return null;
-    }
-
-    logger.info('[getLastMessages] Found messages', { count: messages.length, code: maskSensitiveValue(code) });
-    return messages;
-  } catch (error) {
-    logger.error('[getLastMessages] Error', { code: maskSensitiveValue(code), error: error.message });
-    return null;
-  }
-}
-
-async function getLastNMessages(code, n, before = null, options = {}) {
-  try {
-    const query = { numero: code, ...options.query };
-    if (before) query.createdAt = { [options.beforeOperator || '$lte']: before };
-
-    const messages = await Message.find(query)
-      .select(options.select || null)
-      .sort(options.sort || { createdAt: -1 })
-      .limit(n)
-      .lean();
-
-    logger.debug('[getLastNMessages] Retrieved', { count: messages?.length || 0, code: maskSensitiveValue(code), n });
-    return messages || [];
-  } catch (error) {
-    logger.error('[getLastNMessages] Error', { code: maskSensitiveValue(code), n, error: error.message });
-    return [];
-  }
-}
+const { getMessages } = require('../services/messageService');
 
 function formatMessage(reply) {
   try {
@@ -142,20 +83,18 @@ function getMessageTools(reply) {
   }
 }
 
-async function isRecentMessage(chatId) {
-  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
-  const recent = await Message.findOne({
-    $or: [{ group_id: chatId }, { numero: chatId }],
-    createdAt: { $gte: fiveMinutesAgo }
-  }).sort({ createdAt: -1 });
-  return !!recent;
+async function getLastNMessages(code, n, anchor = null, opts = {}) {
+  const { beforeOperator = '$lte', query: extraQuery = {} } = opts;
+  const query = {
+    ...extraQuery,
+    numero: code,
+    ...(anchor ? { createdAt: { [beforeOperator]: anchor } } : {}),
+  };
+  return getMessages(query, { sort: { createdAt: -1 }, limit: n });
 }
 
 module.exports = {
-  storeProcessedContent,
-  getLastMessages,
-  getLastNMessages,
   formatMessage,
   getMessageTools,
-  isRecentMessage
+  getLastNMessages,
 };

package/lib/helpers/messageStatusHelper.js

@@ -10,6 +10,7 @@ const { handle24HourWindowError } = require('../helpers/templateRecoveryHelper')
 const { updateDeliveryAttemptByTwilioSid } = require('../helpers/deliveryAttemptHelper');
 
 const { addLinkedRecord, updateRecordByFilter } = require('../services/airtableService');
+const { getMessages } = require('../services/messageService');
 
 async function updateMessageStatus(messageSid, status, errorCode = null, errorMessage = null) {
   try {
@@ -114,9 +115,8 @@ async function handleStatusCallback(twilioStatusData, { eventBus } = {}) {
 
 async function getMessageStatus(messageSid) {
   try {
-    return await Message.findOne({ message_id: messageSid })
-      .select('statusInfo message_id numero body')
-      .lean();
+    const [msg] = await getMessages({ message_id: messageSid }, { select: 'statusInfo message_id numero body', limit: 1 });
+    return msg ?? null;
   } catch (error) {
     logger.error('[MessageStatus] Error fetching status', { messageSid, error: error.message });
     return null;

package/lib/helpers/nerHelper.js

@@ -0,0 +1,64 @@
+const STRUCTURED_PATTERNS = [
+  {
+    label: 'TELEFONO',
+    regex: /(?<!\d)(?:(?:\+?52[\s-]?)?(?:\d{2,3}[\s-]\d{3,4}[\s-]\d{4}|\d{10})|(?:\+?51[\s-]?)?9\d{2}[\s-]?\d{3}[\s-]?\d{3})(?!\d)/g,
+  },
+  {
+    label: 'EMAIL',
+    regex: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
+  },
+  {
+    label: 'ID',
+    regex: /(?<!\w)(?:[A-Z]{4}\d{6}[HM][A-Z]{5}[A-Z\d]\d|[A-ZÑ&]{3,4}\d{6}[A-Z\d]{3}|\d{8})\b/g,
+  },
+];
+
+const WORD_CHARS = '0-9A-Za-z_ÁÉÍÓÚÑáéíóúñ';
+const NAME_REGEX = new RegExp(`(?<![${WORD_CHARS}])([A-ZÁÉÍÓÚÑ][a-záéíóúñ]{1,}(?:\\s+[A-ZÁÉÍÓÚÑ][a-záéíóúñ]{1,}){1,3})(?![${WORD_CHARS}])`, 'g');
+
+const detectStructured = (text) => {
+  const entities = [];
+  for (const { label, regex } of STRUCTURED_PATTERNS) {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      entities.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        plaintext: match[0],
+        label,
+        score: null,
+      });
+    }
+  }
+  return entities;
+};
+
+const personaFallback = (text) => {
+  const entities = [];
+  NAME_REGEX.lastIndex = 0;
+  let match;
+  while ((match = NAME_REGEX.exec(text)) !== null) {
+    entities.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      plaintext: match[0],
+      label: 'PERSONA',
+      score: null,
+    });
+  }
+  return entities;
+};
+
+const mergeSpans = (bert, structured) => {
+  const filtered = bert.filter((b) =>
+    !structured.some((s) => b.start < s.end && b.end > s.start)
+  );
+  return [...filtered, ...structured].sort((a, b) => a.start - b.start);
+};
+
+module.exports = {
+  detectStructured,
+  personaFallback,
+  mergeSpans,
+};

package/lib/helpers/templateRecoveryHelper.js

@@ -103,6 +103,8 @@ async function triggerTemplateRecovery(messageDoc, { source = 'reactive', messag
       messageId: messageDocId,
       originalMessageSid: messageSid
     });
+
+    return { delivered: false, deferred: true };
   } catch (error) {
     logger.error('[TemplateRecovery] Error', { source, messageSid, error: error.message });
   }

package/lib/index.d.ts

@@ -246,7 +246,7 @@ declare module '@peopl-health/nexus' {
     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>;
+    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<string | null>;
     isConnected(): boolean;
     disconnect(): Promise<void>;
   }
@@ -289,6 +289,12 @@ declare module '@peopl-health/nexus' {
     messaging?: any;
   }
 
+  export interface NerOptions {
+    nerUrl?: string;
+    nerApiKey?: string;
+    nerTimeoutMs?: number;
+  }
+
   export interface InitializeOptions {
     provider?: 'twilio' | 'baileys';
     providerConfig?: TwilioConfig | BaileysConfig;
@@ -297,6 +303,15 @@ declare module '@peopl-health/nexus' {
     assistant?: AssistantConfig;
     parser?: boolean;
     parserConfig?: ParserConfig;
+    ner?: NerOptions;
+  }
+
+  export interface NerEntity {
+    start: number;
+    end: number;
+    plaintext: string;
+    label: string;
+    score: number | null;
   }
 
   export class Nexus {

package/lib/jobs/ScheduledMessageJob.js

@@ -16,13 +16,12 @@ const TERMINAL_STATUSES = ['sent', 'cancelled'];
 const STALE_SENDING_MS = 5 * 60 * 1000;
 
 class ScheduledMessageJob extends BaseJob {
-  constructor({ queueAdapter, sendMessage, requireMessageStorage = null, requireProvider = null } = {}) {
+  constructor({ queueAdapter, sendMessage, requireProvider = null } = {}) {
     super({ queueAdapter, queueName: QUEUE_NAME });
     if (typeof sendMessage !== 'function') {
       throw new Error('ScheduledMessageJob requires a sendMessage function');
     }
     this.sendMessage = sendMessage;
-    this.requireMessageStorage = requireMessageStorage;
     this.requireProvider = requireProvider;
   }
 
@@ -94,26 +93,11 @@ class ScheduledMessageJob extends BaseJob {
     }
 
     try {
-      let parentMessageId = msg.parentMessageId || null;
-      if (!parentMessageId) {
-        if (msg.contentSid && !msg.message) {
-          const provider = this.requireProvider?.();
-          const rendered = await provider?.renderTemplate?.(msg.contentSid, msg.variables);
-          if (rendered) msg.message = rendered;
-        }
-        const storage = this.requireMessageStorage?.();
-        if (storage?.savePendingMessage) {
-          const parent = await storage.savePendingMessage({
-            code: msg.code, body: msg.message, fileUrl: msg.fileUrl, fileType: msg.fileType,
-            contentSid: msg.contentSid, variables: msg.variables,
-            fromMe: true, processed: true,
-            frontendId: msg.frontendId, triggeredBy: msg.triggeredBy
-          });
-          parentMessageId = parent?._id || null;
-          if (parentMessageId) {
-            await ScheduledMessage.updateOne({ _id: scheduledMessageId }, { $set: { parentMessageId } });
-          }
-        }
+      const parentMessageId = msg.parentMessageId || null;
+      if (!parentMessageId && msg.contentSid && !msg.message) {
+        const provider = this.requireProvider?.();
+        const rendered = await provider?.renderTemplate?.(msg.contentSid, msg.variables);
+        if (rendered) msg.message = rendered;
       }
 
       const result = await this.sendMessage({
@@ -124,7 +108,15 @@ class ScheduledMessageJob extends BaseJob {
         contentSid: msg.contentSid,
         variables: msg.variables,
         hidePreview: msg.hidePreview,
-        parentMessageId
+        frontendId: msg.frontendId,
+        triggeredBy: msg.triggeredBy,
+        processed: true,
+        ...(parentMessageId ? { parentMessageId } : {
+          onParentMessageId: async (id) => {
+            if (!id) return;
+            await ScheduledMessage.updateOne({ _id: scheduledMessageId }, { $set: { parentMessageId: String(id) } });
+          },
+        }),
       });
 
       const messageId = result?.messageId || result?.sid || null;

package/lib/jobs/TemplateApprovalJob.js

@@ -1,6 +1,9 @@
 const { logger } = require('../utils/logger');
 const { Message } = require('../models/messageModel');
 const { DeliveryAttempt } = require('../models/deliveryAttemptModel');
+
+const { getMessages } = require('../services/messageService');
+
 const { BaseJob } = require('./BaseJob');
 
 const QUEUE_NAME = 'template-approval';
@@ -48,7 +51,7 @@ class TemplateApprovalJob extends BaseJob {
   }
 
   async _process({ templateSid, messageId, originalMessageSid, attempt = 0 }) {
-    const message = await Message.findById(messageId).lean();
+    const [message] = await getMessages({ _id: messageId }, { limit: 1 });
 
     if (!message) {
       logger.warn('[TemplateApprovalJob] Message not found', { messageId, templateSid });

package/lib/memory/DefaultMemoryManager.js

@@ -4,11 +4,12 @@ const { logger } = require('../utils/logger');
 
 const { MemoryManager } = require('../memory/MemoryManager');
 
-const { getLastNMessages, getMessageTools, formatMessage } = require('../helpers/messageHelper');
+const { getMessageTools, formatMessage } = require('../helpers/messageHelper');
 
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
 
 const { getRecordByFilter } = require('../services/airtableService');
+const { getMessages } = require('../services/messageService');
 
 class DefaultMemoryManager extends MemoryManager {
   constructor(options = {}) {
@@ -21,10 +22,9 @@ class DefaultMemoryManager extends MemoryManager {
 
     try {
       const beforeCheckpoint = config.beforeCheckpoint ?? message?.createdAt ?? null;
-      const allMessages = await getLastNMessages(thread.code, this.maxHistoricalMessages, beforeCheckpoint, {
-        query: { origin: { $ne: 'instruction' } },
-        beforeOperator: config.beforeOperator || '$lte',
-      });
+      const query = { numero: thread.code, origin: { $ne: 'instruction' } };
+      if (beforeCheckpoint) query.createdAt = { [config.beforeOperator || '$lte']: beforeCheckpoint };
+      const allMessages = await getMessages(query, { sort: { createdAt: -1 }, limit: this.maxHistoricalMessages });
       const additional = config.additionalMessages || [];
 
       if (!allMessages?.length) {

package/lib/memory/SessionManager.js

@@ -1,7 +1,7 @@
 const { logger } = require('../utils/logger');
 const { isBenchMode } = require('../utils/benchModeHelper');
 
-const { Message } = require('../models/messageModel');
+const { getMessages } = require('../services/messageService');
 
 const { MemoryExtractor } = require('./MemoryExtractor');
 
@@ -77,11 +77,8 @@ class SessionManager {
   }
 
   _fetchSessionMessages(numero, sessionStart) {
-    return Message.find({
-      numero,
-      origin: { $ne: 'instruction' },
-      createdAt: { $gte: new Date(sessionStart) },
-    }).sort({ createdAt: 1 }).lean();
+    const query = { numero, origin: { $ne: 'instruction' }, createdAt: { $gte: new Date(sessionStart) } };
+    return getMessages(query, { sort: { createdAt: 1 } });
   }
 
   _generateSessionId(numero) {

package/lib/models/deliveryAttemptModel.js

@@ -2,7 +2,7 @@ const mongoose = require('mongoose');
 
 const KIND_VALUES = ['freeform', 'template', 'recovery_template', 'recovery_template_setup'];
 const STATUS_VALUES = [null, 'queued', 'sending', 'sent', 'delivered', 'undelivered', 'failed', 'read'];
-const TERMINAL_STATUS_VALUES = ['delivered', 'read', 'failed', 'undelivered'];
+const TERMINAL_STATUS_VALUES = ['read', 'failed', 'undelivered'];
 const ERROR_SOURCE_VALUES = [null, 'twilio_sync', 'twilio_async', 'server'];
 
 const deliveryAttemptSchema = new mongoose.Schema({

package/lib/models/globalEntityMapModel.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+
+const { getDb, getModelDatabase } = require('../config/mongoConfig');
+
+const { logger } = require('../utils/logger');
+
+const GLOBAL_ENTITY_CATEGORIES = Object.freeze(['STAFF', 'DOCTOR', 'INTERNAL_EMAIL', 'LOCATION', 'BANK_ACCOUNT']);
+
+const globalEntityMapSchema = new mongoose.Schema({
+  category: { type: String, enum: GLOBAL_ENTITY_CATEGORIES, required: true },
+  encode: { type: Map, of: String, default: () => new Map() },
+  decode: { type: Map, of: String, default: () => new Map() },
+}, { timestamps: true });
+
+globalEntityMapSchema.index({ category: 1 }, { unique: true });
+
+const getGlobalEntityMap = () => {
+  const dbName = getModelDatabase('GlobalEntityMap');
+  const db = dbName ? getDb(dbName) : mongoose;
+  logger.debug('[GlobalEntityMap] Using database', { dbName: dbName || 'default' });
+  return db.models.GlobalEntityMap || db.model('GlobalEntityMap', globalEntityMapSchema);
+};
+
+module.exports = {
+  getGlobalEntityMap,
+  GLOBAL_ENTITY_CATEGORIES,
+};

package/lib/models/messageModel.js

@@ -1,18 +1,7 @@
 const mongoose = require('mongoose');
 
-const { Monitoreo_ID } = require('../config/airtableConfig');
-
-const { logger } = require('../utils/logger');
-
-const { getClinicalContext } = require('../helpers/patientInformationHelper');
-
-const { updateRecordByFilter } = require('../services/airtableService');
 const { DELIVERY_ATTEMPT_STATUSES } = require('./deliveryAttemptModel');
 
-const { Thread } = require('./threadModel');
-
-const INTERNAL_ORIGINS = new Set(['system', 'instruction']);
-
 const messageSchema = new mongoose.Schema({
   raw: { type: Object, default: null },
   body: { type: String, default: '' },
@@ -109,67 +98,6 @@ messageSchema.index({ triggeredBy: 1, createdAt: -1 }, { name: 'triggered_by_idx
 
 const Message = mongoose.model('Message', messageSchema);
 
-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;
-  }
-}
-
 function getMessageValues(message, content) {
   return {
     nombre_whatsapp: message.pushName,
@@ -181,29 +109,7 @@ function getMessageValues(message, content) {
   };
 }
 
-async function getContactDisplayName(contactNumber) {
-  try {
-    const latestMessage = await Message.findOne({ 
-      numero: contactNumber,
-      from_me: false
-    })
-      .sort({ createdAt: -1 })
-      .select('nombre_whatsapp');
-
-    if (latestMessage && latestMessage.nombre_whatsapp && latestMessage.nombre_whatsapp.trim() !== '') {
-      return latestMessage.nombre_whatsapp;
-    } else {
-      return contactNumber;
-    }
-  } catch (error) {
-    logger.error('[MongoStorage] Error fetching display name for ${contactNumber}:', error);
-    return contactNumber;
-  }
-}
-
 module.exports = {
   Message,
-  insertMessage,
   getMessageValues,
-  getContactDisplayName
 };

package/lib/models/tokenMapModel.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose');
+
+const { getDb, getModelDatabase } = require('../config/mongoConfig');
+
+const { logger } = require('../utils/logger');
+
+const PHI_CATEGORIES = Object.freeze(['PERSONA', 'TELEFONO', 'EMAIL', 'ID']);
+
+const tokenMapSchema = new mongoose.Schema({
+  code:   { type: String, required: true },
+  encode: { type: Map, of: String, default: () => new Map() },
+  decode: { type: Map, of: String, default: () => new Map() }
+}, { timestamps: true });
+
+tokenMapSchema.index({ code: 1 }, { unique: true });
+
+const getTokenMap = () => {
+  const dbName = getModelDatabase('TokenMap');
+  const db = dbName ? getDb(dbName) : mongoose;
+  logger.debug('[TokenMap] Using database', { dbName: dbName || 'default' });
+  return db.models.TokenMap || db.model('TokenMap', tokenMapSchema);
+};
+
+module.exports = {
+  getTokenMap,
+  tokenMapSchema,
+  PHI_CATEGORIES,
+};