@peopl-health/nexus 2.5.6-fix-switch → 2.5.7

package/lib/adapters/TwilioProvider.js

@@ -2,6 +2,7 @@ const { MessageProvider } = require('../core/MessageProvider');
 const axios = require('axios');
 const runtimeConfig = require('../config/runtimeConfig');
 const { uploadMediaToS3, getFileExtension } = require('../helpers/mediaHelper');
+const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { sanitizeMediaFilename } = require('../utils/sanitizer');
 const { generatePresignedUrl } = require('../config/awsConfig');
 const { validateMedia, getMediaType } = require('../utils/mediaValidator');
@@ -35,13 +36,6 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
-  ensureWhatsAppFormat(number) {
-    if (!number) return null;
-    if (number.startsWith('whatsapp:')) return number;
-    if (number.startsWith('+')) return `whatsapp:${number}`;
-    return `whatsapp:+${number}`;
-  }
-
   async sendMessage(messageData) {
     if (!this.isConnected || !this.twilioClient) {
       throw new Error('Twilio provider not initialized');
@@ -49,8 +43,8 @@ class TwilioProvider extends MessageProvider {
 
     const { code, body, fileUrl, fileType, variables, contentSid } = messageData;
 
-    const formattedFrom = this.ensureWhatsAppFormat(this.whatsappNumber);
-    const formattedCode = this.ensureWhatsAppFormat(code);
+    const formattedFrom = ensureWhatsAppFormat(this.whatsappNumber);
+    const formattedCode = ensureWhatsAppFormat(code);
 
 
     if (!formattedFrom || !formattedCode) {

package/lib/controllers/conversationController.js

@@ -3,6 +3,7 @@ const llmConfig = require('../config/llmConfig');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 const { Thread } = require('../models/threadModel');
 const { withThreadRecovery } = require('../helpers/threadRecoveryHelper');
+const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { getRecordByFilter } = require('../services/airtableService');
 const { fetchConversationData, processConversations } = require('../services/conversationService');
 const { sendMessage } = require('../core/NexusMessaging');
@@ -107,7 +108,7 @@ const getConversationMessagesController = async (req, res) => {
     const limit = parseInt(req.query.limit) || 50;
     const { before } = req.query;
         
-    const query = { numero: phoneNumber, is_group: false };
+    const query = { numero: phoneNumber, groud_id: null };
     if (before) {
       try {
         query.createdAt = { $lt: new Date(before) };
@@ -139,7 +140,7 @@ const getConversationMessagesController = async (req, res) => {
             return true;
           }
           
-          if (msg.is_media === true) {
+          if (msg.media) {
             if (!msg.media || typeof msg.media !== 'object') {
               logger.warn('Found media message with invalid media data:', msg._id);
               return true;
@@ -180,7 +181,7 @@ const getConversationMessagesController = async (req, res) => {
           body: msg.body || '[Message content unavailable]',
           createdAt: msg.createdAt || new Date(),
           from_me: !!msg.from_me,
-          is_media: !!msg.is_media,
+          is_media: !!msg.media,
           error: 'Message contained non-serializable data'
         };
       }
@@ -223,9 +224,7 @@ const getConversationReplyController = async (req, res) => {
       });
     }
         
-    const formattedPhoneNumber = phoneNumber?.startsWith('whatsapp:') 
-      ? phoneNumber 
-      : `whatsapp:${phoneNumber}`;
+    const formattedPhoneNumber = ensureWhatsAppFormat(phoneNumber);
     logger.info('Formatted phone number:', formattedPhoneNumber);
     
     const messageData = {
@@ -315,7 +314,7 @@ const searchConversationsController = async (req, res) => {
     // Search through all conversations in the database
     const conversations = await Message.aggregate([
       { $match: { 
-        is_group: false,
+        group_id: null,
         $or: [
           { numero: { $regex: escapedQuery, $options: 'i' } },
           { nombre_whatsapp: { $regex: escapedQuery, $options: 'i' } },
@@ -327,7 +326,6 @@ const searchConversationsController = async (req, res) => {
         body: 1,
         createdAt: 1,
         timestamp: 1,
-        is_media: 1,
         media: 1,
         nombre_whatsapp: 1,
         from_me: 1
@@ -403,7 +401,7 @@ const searchConversationsController = async (req, res) => {
         };
       }
 
-      const isMedia = conv.latestMessage.is_media === true;
+      const isMedia = !!conv.latestMessage.media;
       let mediaType = null;
 
       if (isMedia && conv?.latestMessage?.media) {
@@ -458,7 +456,7 @@ const searchConversationsController = async (req, res) => {
 const getConversationsByNameController = async (req, res) => {
   try {
     const conversations = await Message.aggregate([
-      { $match: { from_me: false, is_group: false } },
+      { $match: { from_me: false, groud_id: null } },
       { $sort: { createdAt: -1 } },
       { $group: {
         _id: '$numero',
@@ -511,7 +509,7 @@ const getNewMessagesController = async (req, res) => {
         
     const query = { 
       numero: phoneNumber, 
-      is_group: false,
+      group_id: null,
       createdAt: { $gt: lastMessage.createdAt }
     };
         
@@ -593,12 +591,8 @@ const sendTemplateToNewNumberController = async (req, res) => {
       });
     }
 
-    // Format phone number for WhatsApp if needed
-    const formattedPhoneNumber = phoneNumber.startsWith('whatsapp:') 
-      ? phoneNumber 
-      : `whatsapp:${phoneNumber}`;
+    const formattedPhoneNumber = ensureWhatsAppFormat(phoneNumber);
     
-    // Log template details for debugging
     logger.info('Sending template to new number with details:', { 
       phoneNumber: formattedPhoneNumber,
       templateId,

package/lib/controllers/messageController.js

@@ -1,11 +1,12 @@
+const runtimeConfig = require('../config/runtimeConfig');
 const { Message } = require('../models/messageModel.js');
 const { ScheduledMessage: DefaultScheduledMessage } = require('../models/agendaMessageModel.js');
 const {
   sendMessage: defaultSendMessage,
   sendScheduledMessage: defaultSendScheduledMessage
 } = require('../core/NexusMessaging');
+const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { getRecordByFilter: defaultGetRecordByFilter } = require('../services/airtableService');
-const runtimeConfig = require('../config/runtimeConfig');
 const { logger } = require('../utils/logger');
 const moment = require('moment-timezone');
 
@@ -58,29 +59,6 @@ const pickMessageId = (result, fallbackDoc) => {
   return null;
 };
 
-const normalizeCode = (code) => {
-  if (!code || typeof code !== 'string') return code;
-
-  const trimmed = code.trim();
-  if (trimmed.startsWith('whatsapp:')) {
-    return trimmed;
-  }
-
-  if (trimmed.includes('@')) {
-    return trimmed;
-  }
-
-  if (trimmed.startsWith('+')) {
-    return `whatsapp:${trimmed}`;
-  }
-
-  if (/^\d+$/.test(trimmed)) {
-    return `whatsapp:+${trimmed}`;
-  }
-
-  return trimmed;
-};
-
 const sendMessageController = async (req, res) => {
   const {
     fileUrl,
@@ -112,7 +90,7 @@ const sendMessageController = async (req, res) => {
       sendTime: sendMoment,
       contentSid,
       hidePreview,
-      code: normalizeCode(code),
+      code: ensureWhatsAppFormat(code),
       author,
       extraDelay: 0,
       variables
@@ -173,7 +151,7 @@ const sendBulkMessageController = async (req, res) => {
         sendTime: new Date(sendMoment + extraDelay),
         contentSid,
         hidePreview,
-        code: normalizeCode(recipient),
+        code: ensureWhatsAppFormat(recipient),
         author,
         extraDelay,
         variables
@@ -269,7 +247,7 @@ const sendBulkMessageAirtableController = async (req, res) => {
       let code = row[columnPhone];
       if (Array.isArray(code)) code = code[0];
       if (!code) continue;
-      code = normalizeCode(code);
+      code = ensureWhatsAppFormat(code);
 
       if (sentPhones.has(code)) continue;
       sentPhones.add(code);
@@ -323,7 +301,7 @@ const sendBulkMessageAirtableController = async (req, res) => {
 
 const getLastInteractionController = async (req, res) => {
   const { code } = req.query;
-  const normalizedCode = normalizeCode(code);
+  const normalizedCode = ensureWhatsAppFormat(code);
 
   try {
     const lastMessage = await Message.findOne({
@@ -355,7 +333,7 @@ const checkScheduledMessageStatusController = async (req, res) => {
   if (!ensureDependency(res, dependencies.ScheduledMessage, 'ScheduledMessage model not configured.')) return;
 
   try {
-    const msg = await dependencies.ScheduledMessage.findOne({ contentSid, code: normalizeCode(code) });
+    const msg = await dependencies.ScheduledMessage.findOne({ contentSid, code: ensureWhatsAppFormat(code) });
     if (!msg) return res.status(404).send({ message: 'ScheduledMessage not found' });
     return res.status(200).send({ message: 'ScheduledMessage status retrieved successfully.', sent: msg?.status === 'sent', status: msg?.status || null });
   } catch (error) {
@@ -369,7 +347,7 @@ const checkMessageStatusController = async (req, res) => {
   if (!contentSid || !code) return res.status(400).send({ message: 'contentSid and code are required' });
 
   try {
-    const msg = await Message.findOne({ content_sid: contentSid, numero: normalizeCode(code) });
+    const msg = await Message.findOne({ content_sid: contentSid, numero: ensureWhatsAppFormat(code) });
     if (!msg) return res.status(404).send({ message: 'Message not found' });
     const sent = msg?.statusInfo?.status === 'sent' || msg?.statusInfo?.status === 'delivered' || msg?.statusInfo?.status === 'read';
     return res.status(200).send({ message: 'Message status retrieved successfully.', sent, status: msg?.statusInfo?.status || null });

package/lib/core/NexusMessaging.js

@@ -585,9 +585,7 @@ class NexusMessaging {
         const messageObj = convertTwilioToInternalFormat(raw);
         const values = getMessageValues(
           messageObj,
-          messageData.body || messageData.caption || '',
-          null,
-          true
+          messageData.body || messageData.caption || ''
         );
         values.media = mediaPayload;
 

package/lib/helpers/baileysHelper.js

@@ -15,7 +15,7 @@ async function processMessage(message, messageType) {
       return;
     }
 
-    const values = getMessageValues(message, content, reply, false);
+    const values = getMessageValues(message, content);
     await insertMessage(values);
 
     return values;
@@ -28,7 +28,7 @@ async function processMessage(message, messageType) {
 async function processMediaMessage(message, logger, messageType, bucketName, sock) {
   try {
     const { content, contentType, reply } = extractContentTypeAndReply(message, messageType);
-    let values = getMessageValues(message, content, reply, true);
+    let values = getMessageValues(message, content);
     // Insert message into the message database
 
     const messageID = message.key.id;
@@ -108,7 +108,7 @@ function extractContentTypeAndReply(message, messageType) {
 }
 
 async function getLastMessages(chatId, n) {
-  const messages = await Message.find({ group_id: chatId })
+  const messages = await Message.find({ numero: chatId })
     .sort({ createdAt: -1 })
     .limit(n)
     .select('timestamp numero nombre_whatsapp body');

package/lib/helpers/processHelper.js

@@ -213,7 +213,7 @@ const processMediaFilesCore = async (code, reply, provider) => {
     url_generation_ms: 0
   };
 
-  if (!reply.is_media) {
+  if (!reply.media) {
     return { messagesChat, url, tempFiles, timings };
   }
 
@@ -282,7 +282,7 @@ const processMediaFiles = withTracing(
   'process_media_files',
   (code, reply) => ({
     'media.message_id': reply.message_id,
-    'media.is_media': reply.is_media
+    'media.is_media': !!reply.media
   })
 );
 
@@ -325,7 +325,7 @@ const processThreadMessageCore = async (code, replies, provider) => {
           index: i + 1, 
           total: replyArray.length,
           isPatient,
-          hasMedia: reply.is_media,
+          hasMedia: !!reply.media,
           hasUrl: !!url
         });
         

package/lib/helpers/twilioHelper.js

@@ -104,13 +104,14 @@ async function downloadMedia(twilioMessage, logger) {
 
 
 const ensureWhatsAppFormat = (phoneNumber) => {
-  if (!phoneNumber) return null;
-    
-  if (phoneNumber.startsWith('whatsapp:')) {
-    return phoneNumber;
-  }
-    
-  return `whatsapp:${phoneNumber}`;
+  if (!phoneNumber || typeof phoneNumber !== 'string') return phoneNumber;
+
+  const trimmed = phoneNumber.trim();
+  if (trimmed.startsWith('whatsapp:')) return trimmed;
+  if (trimmed.includes('@')) return trimmed;
+  if (trimmed.startsWith('+')) return `whatsapp:${trimmed}`;
+  if (/^\d+$/.test(trimmed)) return `whatsapp:+${trimmed}`;
+  return trimmed;
 };
 
 

package/lib/index.d.ts

@@ -286,7 +286,7 @@ declare module '@peopl-health/nexus' {
   export function delay(ms: number): Promise<void>;
   export function formatCode(codeBase: string): string;
   export function calculateDelay(sendTime: string | Date, timeZone?: string): number;
-  export function ensureWhatsAppFormat(phoneNumber: string): string | null;
+  export function ensureWhatsAppFormat(phoneNumber: any): string | null;
   export function convertTwilioToInternalFormat(twilioMessage: any): any;
   export function downloadMediaFromTwilio(mediaUrl: string, credentials: any): Promise<Buffer>;
   export function getMediaTypeFromContentType(contentType: string): string;
@@ -296,7 +296,7 @@ declare module '@peopl-health/nexus' {
   // Models
   export const Message: mongoose.Model<any>;
   export const Thread: mongoose.Model<any>;
-  export function getMessageValues(message: any, content: string, reply?: string, is_media?: boolean): any;
+  export function getMessageValues(message: any, content: string): any;
   export function formatTimestamp(unixTimestamp: number): string;
 
   // Module Exports

package/lib/models/messageModel.js

@@ -6,15 +6,12 @@ const { logger } = require('../utils/logger');
 
 
 const messageSchema = new mongoose.Schema({
-  raw: { type: Object, required: false },
-  nombre_whatsapp: { type: String, required: true },
-  numero: { type: String, required: true },
+  raw: { type: Object, default: null },
   body: { type: String, required: true },
+  numero: { type: String, required: true },
+  nombre_whatsapp: { type: String, default: null },
   timestamp: { type: String, required: true, default: Date.now },
-  message_id: { type: String, required: true },
-  is_group: { type: Boolean, required: true },
-  is_media: { type: Boolean, required: true },
-  is_interactive: { type: Boolean, default: false },
+  message_id: { type: String, default: null},
   interactive_type: { 
     type: String, 
     enum: ['button', 'list', 'flow', 'quick_reply'], 
@@ -22,30 +19,37 @@ const messageSchema = new mongoose.Schema({
   },
   interactive_data: { type: Object, default: null },
   group_id: { type: String, default: null },
-  reply_id: { type: String, default: null },
   processed: { type: Boolean, default: false },
-  thread_id: { type: String, default: null },
+  read: { type: Boolean, default: false },
   assistant_id: { type: String, default: null },
   content_sid: { type: String, default: null },
   from_me: { type: Boolean, default: false },
   origin: { 
     type: String, 
     enum: ['whatsapp_platform', 'assistant', 'patient', 'system', 'instruction'], 
-    default: 'whatsapp_platform' },
-  tools_executed: [{
-    tool_name: { type: String, required: true },
-    tool_arguments: { type: Object, default: null },
-    tool_output: { type: Object, default: null },
-    execution_time_ms: { type: Number, default: null },
-    success: { type: Boolean, default: true },
-    call_id: { type: String, default: null },
-    executed_at: { type: Date, default: Date.now }
-  }],
+    default: 'whatsapp_platform' 
+  },
+  tools_executed: {
+    type: [{
+      tool_name: { type: String, required: true },
+      tool_arguments: { type: Object, default: null },
+      tool_output: { type: Object, default: null },
+      execution_time_ms: { type: Number, default: null },
+      success: { type: Boolean, default: true },
+      call_id: { type: String, default: null },
+      executed_at: { type: Date, default: Date.now }
+    }],
+    default: []
+  },
   media: {
     contentType: { type: String, default: null },
     bucketName: { type: String, default: null },
     key: { type: String, default: null },
-    mediaType: { type: String, enum: ['image', 'video', 'audio', 'document', 'sticker', 'other'], default: null },
+    mediaType: { 
+      type: String, 
+      enum: ['image', 'video', 'audio', 'document', 'sticker', 'other'], 
+      default: null 
+    },
     fileName: { type: String, default: null },
     fileSize: { type: Number, default: null },
     duration: { type: Number, default: null },
@@ -60,34 +64,19 @@ const messageSchema = new mongoose.Schema({
     default: 'active',
     index: true
   },
-  read: {
-    type: Boolean,
-    default: false
-  },
   statusInfo: {
     status: {
       type: String,
       enum: ['queued', 'sending', 'sent', 'delivered', 'undelivered', 'failed', 'read', null],
       default: null
     },
-    errorCode: {
-      type: String,
-      default: null
-    },
-    errorMessage: {
-      type: String,
-      default: null
-    },
-    updatedAt: {
-      type: Date,
-      default: null
-    }
+    errorCode: { type: String, default: null },
+    errorMessage: { type: String, default: null },
+    updatedAt: { type: Date, default: null }
   }
 }, { timestamps: true });
 
-messageSchema.index({ message_id: 1, timestamp: 1 }, { unique: true });
 messageSchema.index({ numero: 1, createdAt: -1 });
-
 messageSchema.index({ numero: 1, processed: 1, origin: 1 }, { name: 'numero_processed_origin_idx' });
 messageSchema.index({ numero: 1, createdAt: -1, processed: 1 }, { name: 'numero_created_processed_idx' });
 
@@ -115,47 +104,30 @@ async function getClinicalContext(whatsappId) {
 
 async function insertMessage(values) {
   try {
-    const skipNumbers = ['5215592261426@s.whatsapp.net', '5215547411345@s.whatsapp.net', '51985959446@s.whatsapp.net'];
     const clinical_context = await getClinicalContext(values.numero);
-    const messageData = {
-      nombre_whatsapp: values.nombre_whatsapp,
-      numero: values.numero,
-      body: values.body,
-      timestamp: values.timestamp,
-      message_id: values.message_id,
-      is_group: values.is_group,
-      is_media: values.is_media,
-      is_interactive: values.is_interactive || false,
-      interactive_type: values.interactive_type || null,
-      interactive_data: values.interactive_data || null,
-      group_id: values.group_id,
-      reply_id: values.reply_id,
-      from_me: values.from_me,
-      processed: values.processed || skipNumbers.includes(values.numero),
-      media: values.media ? values.media : null,
-      content_sid: values.content_sid || null,
-      clinical_context: clinical_context,
-      origin: values.origin,
-      tools_executed: values.tools_executed || [],
-      raw: values.raw || null,
-      assistant_id: values.assistant_id || null,
-      statusInfo: values.statusInfo || (values.delivery_status ? {
+    const messageData = Object.fromEntries(
+      Object.entries(values)
+        .filter(([k, v]) => v !== undefined && !k.startsWith('delivery_'))
+    );
+    messageData.clinical_context = clinical_context;
+    if (!messageData.statusInfo && values.delivery_status) {
+      messageData.statusInfo = {
         status: values.delivery_status,
         errorCode: values.delivery_error_code || null,
         errorMessage: values.delivery_error_message || null,
         updatedAt: values.delivery_status_updated_at || null
-      } : null)
-    };
+      };
+    }
 
     await Message.findOneAndUpdate(
       { message_id: values.message_id, body: values.body },
       { $setOnInsert: messageData },
-      { upsert: true, new: true }
+      { upsert: true, new: true, setDefaultsOnInsert: true }
     );
 
     logger.info('[MongoStorage] Message inserted or updated successfully');
   } catch (err) {
-    logger.error('[MongoStorage] Error inserting message:', err);
+    logger.error('[MongoStorage] Error inserting message', { error: err.message, stack: err.stack });
     throw err;
   }
 }
@@ -170,15 +142,13 @@ function formatTimestamp(unixTimestamp) {
 }
 
 
-function getMessageValues(message, content, reply, is_media) {
+function getMessageValues(message, content) {
   const nombre_whatsapp = message.pushName;
   const numero = message.key.participant || message.key.remoteJid;
   const body = content;
   const timestamp = formatTimestamp(message.messageTimestamp);
   const message_id = message.key.id;
-  const is_group = message.key.remoteJid.endsWith('@g.us');
-  const group_id = is_group ? message.key.remoteJid : null;
-  const reply_id = reply || null;
+  const group_id = message.key.remoteJid || null;
   const from_me = message.key.fromMe;
   
   return {
@@ -187,10 +157,7 @@ function getMessageValues(message, content, reply, is_media) {
     body,
     timestamp,
     message_id,
-    is_group,
-    is_media,
     group_id,
-    reply_id,
     from_me
   };
 }

package/lib/services/assistantServiceCore.js

@@ -98,8 +98,6 @@ const addMsgAssistantCore = async (code, inMessages, role = 'user', reply = fals
             numero: code,
             body: message,
             message_id: message_id,
-            is_group: false,
-            is_media: false,
             from_me: true,
             processed: true,
             origin: 'system',
@@ -144,8 +142,6 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
         numero: code,
         body: instruction,
         message_id: message_id,
-        is_group: false,
-        is_media: false,
         from_me: true,
         processed: true,
         origin: 'instruction',

package/lib/services/conversationService.js

@@ -5,270 +5,101 @@ const { logger } = require('../utils/logger');
 
 
 const fetchConversationData = async (filter, skip, limit) => {
-  let filterConditions = { is_group: false };
+  const baseMatch = { group_id: null };
+  const unreadMatch = { from_me: false, $or: [{ read: false }, { read: { $exists: false } }] };
   
-  switch (filter) {
-  case 'unread':
-    filterConditions = { 
-      is_group: false,
-      from_me: false,
-      $or: [
-        { read: false },
-        { read: { $exists: false } }
-      ]
-    };
-    logger.info('Applying unread filter');
-    break;
-
-  case 'no-response':
-    logger.info('Applying no-response filter');
-    break;
-
-  case 'recent': {
-    const yesterday = new Date();
-    yesterday.setDate(yesterday.getDate() - 1);
-    filterConditions = { 
-      is_group: false,
-      createdAt: { $gt: yesterday }
-    };
-    logger.info('Applying recent filter (last 24 hours)');
-    break;
-  }
-
-  case 'all':
-  default:
-    filterConditions = { is_group: false };
-    logger.info('Applying all conversations filter');
-    break;
-  }
-
-  logger.info('Executing aggregation pipeline...');
-  const aggregationStartTime = Date.now();
+  const filterMap = {
+    unread: { ...baseMatch, ...unreadMatch },
+    recent: { ...baseMatch, createdAt: { $gt: new Date(Date.now() - 24 * 60 * 60 * 1000) } },
+    'no-response': baseMatch,
+    all: baseMatch
+  };
+  
+  const filterConditions = filterMap[filter] || baseMatch;
+  logger.info(`Applying ${filter} filter`);
   
-  let aggregationPipeline = [
+  const pipeline = [
     { $match: filterConditions },
-    { $project: {
-      numero: 1,
-      body: 1,
-      createdAt: 1,
-      timestamp: 1,
-      is_media: 1,
-      media: 1,
-      nombre_whatsapp: 1,
-      from_me: 1
-    }},
+    { $project: { numero: 1, body: 1, createdAt: 1, timestamp: 1, media: 1, nombre_whatsapp: 1, from_me: 1 } },
     { $sort: { createdAt: 1, timestamp: 1 } },
-    { $group: {
-      _id: '$numero',
-      latestMessage: { $last: '$$ROOT' },
-      messageCount: { $sum: 1 }
-    }},
-    { $sort: { 'latestMessage.createdAt': -1 } }
-  ];
-
-  if (filter === 'no-response') {
-    aggregationPipeline.splice(-1, 0, { $match: { 'latestMessage.from_me': false } });
-  }
-
-  aggregationPipeline.push(
+    { $group: { _id: '$numero', latestMessage: { $last: '$$ROOT' }, messageCount: { $sum: 1 } } },
+    ...(filter === 'no-response' ? [{ $match: { 'latestMessage.from_me': false } }] : []),
+    { $sort: { 'latestMessage.createdAt': -1 } },
     { $skip: skip },
     { $limit: limit }
-  );
-
-  const conversations = await Message.aggregate(aggregationPipeline);
-
-  const aggregationTime = Date.now() - aggregationStartTime;
-  logger.info(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
-
-  // Fetch names from Airtable and WhatsApp
-  const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
-  const formula = 'OR(' +
-    phoneNumbers.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
-    ')';
-  const patientTable = await getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula);
-  const airtableNameMap = patientTable.reduce((map, patient) => {
-    map[patient.whatsapp_id] = patient.name;
-    return map;
-  }, {});
-  logger.info(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
-
-  const contactNames = await Message.aggregate([
-    { $match: { is_group: false, from_me: false } },
-    { $sort: { createdAt: -1 } },
-    { $group: {
-      _id: '$numero',
-      name: { $first: '$nombre_whatsapp' }
-    }}
-  ]);
-      
-  const nameMap = contactNames?.reduce((map, contact) => {
-    if (contact && contact._id) {
-      if (!airtableNameMap[contact._id]) {
-        map[contact._id] = contact.name || 'Unknown';
-      }
-    }
-    return map;
-  }, {...airtableNameMap}) || airtableNameMap || {};
-      
-  // Fetch unread counts
-  logger.info('Fetching unread counts using Message.aggregate');
-  const unreadCounts = await Message.aggregate([
-    { 
-      $match: { 
-        is_group: false, 
-        from_me: false, 
-        $or: [
-          { read: false },
-          { read: { $exists: false } }
-        ]
-      } 
-    },
-    { $group: {
-      _id: '$numero',
-      unreadCount: { $sum: 1 }
-    }}
-  ]);
-      
-  const unreadMap = unreadCounts?.reduce((map, item) => {
-    if (item && item._id) {
-      map[item._id] = item.unreadCount || 0;
-    }
-    return map;
-  }, {}) || {};
-  logger.info('Unread map calculated', { unreadMap });
-  logger.info('Conversations found', { count: conversations?.length || 0 });
-      
-  // Calculate total count for pagination
-  let totalFilterConditions = { is_group: false };
-
-  if (filter === 'unread') {
-    totalFilterConditions = { 
-      is_group: false,
-      from_me: false,
-      $or: [
-        { read: false },
-        { read: { $exists: false } }
-      ]
-    };
-  } else if (filter === 'recent') {
-    const yesterday = new Date();
-    yesterday.setDate(yesterday.getDate() - 1);
-    totalFilterConditions = { 
-      is_group: false,
-      createdAt: { $gt: yesterday }
-    };
-  }
-
-  let totalAggregationPipeline = [
-    { $match: totalFilterConditions },
-    { $group: { _id: '$numero' } },
-    { $count: 'total' }
   ];
-
-  if (filter === 'no-response') {
-    totalAggregationPipeline = [
-      { $match: { is_group: false } },
-      { $project: {
-        numero: 1,
-        from_me: 1,
-        createdAt: 1,
-        timestamp: 1
-      }},
-      { $sort: { createdAt: -1, timestamp: -1 } },
-      { $group: {
-        _id: '$numero',
-        latestMessage: { $first: '$$ROOT' }
-      }},
-      { $match: { 'latestMessage.from_me': false } },
-      { $count: 'total' }
-    ];
-  }
-
-  const totalConversations = await Message.aggregate(totalAggregationPipeline, { allowDiskUse: true });
-  const total = totalConversations[0]?.total || 0;
-
-  return { conversations, total, nameMap, unreadMap };
+  
+  const startTime = Date.now();
+  const [conversations, contactNames, unreadCounts, totalResult] = await Promise.all([
+    Message.aggregate(pipeline),
+    Message.aggregate([{ $match: { ...baseMatch, from_me: false } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', name: { $first: '$nombre_whatsapp' } } }]),
+    Message.aggregate([{ $match: { ...baseMatch, ...unreadMatch } }, { $group: { _id: '$numero', unreadCount: { $sum: 1 } } }]),
+    Message.aggregate(filter === 'no-response' 
+      ? [{ $match: baseMatch }, { $project: { numero: 1, from_me: 1, createdAt: 1, timestamp: 1 } }, { $sort: { createdAt: -1 } }, { $group: { _id: '$numero', latestMessage: { $first: '$$ROOT' } } }, { $match: { 'latestMessage.from_me': false } }, { $count: 'total' }]
+      : [{ $match: filterConditions }, { $group: { _id: '$numero' } }, { $count: 'total' }]
+    )
+  ]);
+  
+  logger.info(`Queries completed in ${Date.now() - startTime}ms, found ${conversations.length} conversations`);
+  
+  const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
+  const airtableNameMap = phoneNumbers.length ? 
+    (await getRecordByFilter(Historial_Clinico_ID, 'estado_general', `OR(${phoneNumbers.map(p => `{whatsapp_id} = "${p}"`).join(', ')})`)).reduce((map, patient) => ({ ...map, [patient.whatsapp_id]: patient.name }), {}) : {};
+  
+  const nameMap = { ...airtableNameMap, ...contactNames.reduce((map, contact) => contact?._id && !airtableNameMap[contact._id] ? { ...map, [contact._id]: contact.name || 'Unknown' } : map, {}) };
+  const unreadMap = unreadCounts.reduce((map, item) => item?._id ? { ...map, [item._id]: item.unreadCount || 0 } : map, {});
+  
+  return { conversations, total: totalResult[0]?.total || 0, nameMap, unreadMap };
 };
 
 /**
  * Processes conversations to prepare them for the response
  */
 const processConversations = async (conversations, nameMap, unreadMap) => {
-  logger.info('Processing conversations for response...');
-
-  let processedConversations = [];
+  const getMediaType = (media) => {
+    if (!media) return null;
+    if (media.mediaType) return media.mediaType;
+    if (!media.contentType) return null;
+    const [type, subtype] = media.contentType.split('/');
+    return type === 'application' ? 'document' : subtype === 'webp' ? 'sticker' : type;
+  };
+  
+  const createConversation = (conv, index, fallback = {}) => {
+    const msg = conv?.latestMessage;
+    const phoneNumber = conv?._id || fallback.phoneNumber || `error_${index}`;
+    return {
+      phoneNumber,
+      name: nameMap[phoneNumber] || msg?.nombre_whatsapp || fallback.name || 'Unknown',
+      lastMessage: msg?.body || fallback.lastMessage || '',
+      lastMessageTime: msg?.createdAt || msg?.timestamp || new Date(),
+      messageCount: conv?.messageCount || 0,
+      unreadCount: unreadMap[phoneNumber] || 0,
+      isLastMessageMedia: !!msg?.media,
+      lastMessageType: getMediaType(msg?.media),
+      lastMessageFromMe: msg?.from_me || false
+    };
+  };
+  
   try {
-    processedConversations = (conversations || []).map((conv, index) => {
+    const processedConversations = (conversations || []).map((conv, index) => {
       try {
-        if (!conv || !conv.latestMessage) {
-          logger.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
-          return {
-            phoneNumber: conv?._id || 'unknown',
-            name: 'Unknown',
-            lastMessage: '',
-            lastMessageTime: new Date(),
-            messageCount: 0,
-            unreadCount: 0,
-            isLastMessageMedia: false,
-            lastMessageType: null,
-            lastMessageFromMe: false
-          };
-        }
-
-        const isMedia = conv.latestMessage.is_media === true;
-        let mediaType = null;
-
-        if (isMedia && conv?.latestMessage?.media) {
-          if (conv.latestMessage.media.mediaType) {
-            mediaType = conv.latestMessage.media.mediaType;
-          } else if (conv.latestMessage.media.contentType) {
-            const contentType = conv.latestMessage.media.contentType;
-            const contentTypeParts = contentType?.split('/') || ['unknown'];
-            mediaType = contentTypeParts[0] || 'unknown';
-
-            if (mediaType === 'application') {
-              mediaType = 'document';
-            } else if (contentTypeParts[1] === 'webp') {
-              mediaType = 'sticker';
-            }
-          }
+        if (!conv?.latestMessage) {
+          logger.warn(`Conversation ${index} missing latestMessage:`, conv?._id);
+          return createConversation(conv, index, { name: 'Unknown' });
         }
-
-        return {
-          phoneNumber: conv._id,
-          name: nameMap[conv._id] || conv?.latestMessage?.nombre_whatsapp || 'Unknown',
-          lastMessage: conv?.latestMessage?.body || '',
-          lastMessageTime: conv?.latestMessage?.createdAt || conv?.latestMessage?.timestamp || new Date(),
-          messageCount: conv.messageCount || 0,
-          unreadCount: unreadMap[conv._id] || 0,
-          isLastMessageMedia: isMedia || false,
-          lastMessageType: mediaType || null,
-          lastMessageFromMe: conv?.latestMessage?.from_me || false
-        };
-      } catch (convError) {
-        logger.error(`Error processing conversation ${index}:`, convError);
-        return {
-          phoneNumber: conv?._id || `error_${index}`,
-          name: 'Error Processing',
-          lastMessage: 'Error processing conversation',
-          lastMessageTime: new Date(),
-          messageCount: 0,
-          unreadCount: 0,
-          isLastMessageMedia: false,
-          lastMessageType: null,
-          lastMessageFromMe: false
-        };
+        return createConversation(conv, index);
+      } catch (error) {
+        logger.error(`Error processing conversation ${index}:`, error);
+        return createConversation(conv, index, { name: 'Error Processing', lastMessage: 'Error processing conversation' });
       }
     });
-
-    logger.info(`Successfully processed ${processedConversations.length} conversations`);
-  
-  } catch (mappingError) {
-    logger.error('Error in conversation mapping:', mappingError);
-    processedConversations = [];
+    
+    logger.info(`Processed ${processedConversations.length} conversations`);
+    return processedConversations;
+  } catch (error) {
+    logger.error('Error in conversation mapping:', error);
+    return [];
   }
-
-  return processedConversations;
 };
 
 module.exports = {

package/lib/storage/MongoStorage.js

@@ -1,5 +1,12 @@
 const mongoose = require('mongoose');
 const runtimeConfig = require('../config/runtimeConfig');
+
+const { Message, insertMessage } = require('../models/messageModel');
+const { Interaction } = require('../models/interactionModel');
+const { Thread } = require('../models/threadModel');
+
+const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
+const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor'); 
 const { logger } = require('../utils/logger');
 
 /**
@@ -18,10 +25,6 @@ class MongoStorage {
   }
 
   createSchemas() {
-    const { Message } = require('../models/messageModel');
-    const { Interaction } = require('../models/interactionModel');
-    const { Thread } = require('../models/threadModel');
-
     return {
       Message,
       Interaction,
@@ -45,7 +48,6 @@ class MongoStorage {
     try {
       const enrichedMessage = await this._enrichTwilioMedia(messageData);
       const values = this.buildMessageValues(enrichedMessage);
-      const { insertMessage } = require('../models/messageModel');
       await insertMessage(values);
       logger.info('[MongoStorage] Message stored');
       return values;
@@ -76,8 +78,6 @@ class MongoStorage {
         return messageData;
       }
 
-      const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor');
-
       const mediaItems = await processTwilioMediaMessage(rawMessage, bucketName);
       if (!mediaItems || mediaItems.length === 0) {
         logger.warn('[MongoStorage] Media processing returned no items');
@@ -112,52 +112,19 @@ class MongoStorage {
     }
   }
 
-  normalizeNumero(numero) {
-    if (!numero || typeof numero !== 'string') return numero;
-
-    const trimmed = numero.trim();
-    if (trimmed.startsWith('whatsapp:')) {
-      return trimmed;
-    }
-
-    if (trimmed.includes('@')) {
-      return trimmed;
-    }
-
-    if (trimmed.startsWith('+')) {
-      return `whatsapp:${trimmed}`;
-    }
-
-    if (/^\d+$/.test(trimmed)) {
-      return `whatsapp:+${trimmed}`;
-    }
-
-    return trimmed;
-  }
-
-
   buildMessageValues(messageData = {}) {
     const numero = messageData.to || messageData.code || messageData.numero || messageData.from;
-    const rawNumero = typeof numero === 'string' ? numero : '';
-    const normalizedNumero = this.normalizeNumero(rawNumero);
-    const isGroup = normalizedNumero.includes('@g.us');
+    const normalizedNumero = ensureWhatsAppFormat(numero || '');
     const isMedia = messageData.isMedia === true || (messageData.fileType && messageData.fileType !== 'text');
     const now = new Date();
-    const timestamp = now.toISOString();
-    const nombre = messageData.nombre_whatsapp || messageData.author || messageData.fromName || runtimeConfig.get('USER_DB_MONGO') || process.env.USER_DB_MONGO || 'Nexus';
-    const processed = messageData.processed || false;
-    const origin = messageData.origin || 'whatsapp_platform';
     
-    // Use message body directly (template rendering is now handled by the provider)
-    let textBody = messageData.body;
+    const nombre = messageData.nombre_whatsapp || messageData.author || messageData.fromName || 
+                   runtimeConfig.get('USER_DB_MONGO') || process.env.USER_DB_MONGO || 'Nexus';
     
-    if (!textBody && isMedia) {
-      textBody = `[Media:${messageData.fileType || 'attachment'}]`;
-    } else if (!textBody) {
-      textBody = '';
-    }
+    const textBody = messageData.body || (isMedia ? `[Media:${messageData.fileType || 'attachment'}]` : '');
     
-    const providerId = messageData.messageId || messageData.sid || messageData.id || messageData._id || `pending-${now.getTime()}-${Math.floor(Math.random()*1000)}`;
+    const providerId = messageData.messageId || messageData.sid || messageData.id || messageData._id || 
+                       `pending-${now.getTime()}-${Math.floor(Math.random()*1000)}`;
 
     const media = messageData.media || (messageData.fileUrl ? {
       url: messageData.fileUrl,
@@ -167,33 +134,30 @@ class MongoStorage {
       metadata: messageData.mediaMetadata || null
     } : null);
 
+    const statusInfo = messageData.statusInfo || (messageData.delivery_status ? {
+      status: messageData.delivery_status,
+      errorCode: messageData.delivery_error_code || null,
+      errorMessage: messageData.delivery_error_message || null,
+      updatedAt: messageData.delivery_status_updated_at || null
+    } : null);
+
     return {
       nombre_whatsapp: nombre,
       numero: normalizedNumero,
       body: textBody,
-      timestamp,
-      processed,
+      timestamp: now.toISOString(),
+      processed: messageData.processed || false,
       message_id: providerId,
-      is_group: isGroup,
-      is_media: isMedia,
-      is_interactive: messageData.isInteractive || false,
       interactive_type: messageData.interactionType || null,
       interactive_data: messageData.interactiveData || null,
-      group_id: isGroup ? normalizedNumero : null,
-      reply_id: messageData.reply_id || messageData.replyId || null,
       from_me: messageData.fromMe !== undefined ? messageData.fromMe : true,
       media,
       content_sid: messageData.contentSid || null,
       template_variables: messageData.variables ? JSON.stringify(messageData.variables) : null,
       raw: messageData.raw || null,
-      origin,
-      tools_executed: messageData.tools_executed || [],
-      statusInfo: messageData.statusInfo || (messageData.delivery_status ? {
-        status: messageData.delivery_status,
-        errorCode: messageData.delivery_error_code || null,
-        errorMessage: messageData.delivery_error_message || null,
-        updatedAt: messageData.delivery_status_updated_at || null
-      } : null)
+      origin: messageData.origin || 'whatsapp_platform',
+      tools_executed: messageData.tools_executed,
+      statusInfo
     };
   }
 

package/package.json

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