@peopl-health/nexus 2.2.0 → 2.2.2

package/examples/basic-usage.js

@@ -1,10 +1,19 @@
 const express = require('express');
 require('dotenv').config();
-const { Nexus, setupDefaultRoutes } = require('@peopl-health/nexus');
+const { Nexus, setupDefaultRoutes, BaseAssistant } = require('@peopl-health/nexus');
 
 const app = express();
 app.use(express.json());
 
+// Define a General Assistant
+class GeneralAssistant extends BaseAssistant {
+  constructor(options = {}) {
+    super(options);
+    // You can add custom tools or setup here
+    // Example: this.registerTool('toolName', schema, handler);
+  }
+}
+
 async function startServer() {
   // Initialize Nexus with all services and batching enabled
   const nexus = new Nexus({
@@ -33,6 +42,21 @@ async function startServer() {
     media: {
       bucketName: process.env.AWS_S3_BUCKET_NAME,
       region: process.env.AWS_REGION || 'us-east-1'
+    },
+
+    // LLM configuration (required for assistants)
+    llm: 'openai',
+    llmConfig: {
+      apiKey: process.env.OPENAI_API_KEY
+    },
+
+    // Assistants configuration
+    assistants: {
+      registry: {
+        // Register the general assistant with its OpenAI assistant ID
+        'asst_O6mAXAhf0xyVj3t4DHRs26uT': GeneralAssistant,
+        'pmpt_68f844cd975481979c080431bde74f6e0adf01a52110813b': GeneralAssistant,
+      }
     }
   });
 

package/lib/assistants/BaseAssistant.js

@@ -1,6 +1,7 @@
 const llmConfig = require('../config/llmConfig');
 const { Thread } = require('../models/threadModel');
-const { getLastNMessages } = require('../helpers/assistantHelper');
+const { Message } = require('../models/messageModel');
+const { formatMessage } = require('../helpers/assistantHelper');
 const { createProvider } = require('../providers/createProvider');
 
 const DEFAULT_MAX_HISTORICAL_MESSAGES = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
@@ -165,11 +166,6 @@ class BaseAssistant {
     this._ensureClient();
     this.status = 'active';
 
-    const whatsappId = context?.whatsapp_id || code;
-    if (whatsappId) {
-      this.lastMessages = await getLastNMessages(whatsappId, DEFAULT_MAX_HISTORICAL_MESSAGES);
-    }
-
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     if (!provider || typeof provider.createConversation !== 'function') {
       throw new Error('Provider not configured. Cannot create conversation.');
@@ -189,12 +185,39 @@ class BaseAssistant {
     return this.thread;
   }
 
-  async buildInitialMessages({ code }) {
-    if (!this.lastMessages) return [];
-    return [{
-      role: 'assistant',
-      content: `Últimos mensajes para ${code}: \n${this.lastMessages}`
-    }];
+  async buildInitialMessages({ code, context = {} }) {
+    const whatsappId = context?.whatsapp_id || code;
+    if (!whatsappId) {
+      return [];
+    }
+
+    try {
+      const lastMessages = await Message.find({ numero: whatsappId })
+        .sort({ createdAt: -1 })
+        .limit(DEFAULT_MAX_HISTORICAL_MESSAGES);
+
+      if (!lastMessages || lastMessages.length === 0) {
+        return [];
+      }
+
+      const messagesInOrder = lastMessages.reverse();
+
+      // Messages with from_me: true are assistant messages, from_me: false are user messages
+      const formattedMessages = messagesInOrder
+        .filter(message => message && message.timestamp && message.body && message.body.trim() !== '')
+        .map(message => {
+          const formattedText = formatMessage(message);
+          return formattedText ? { role: message.from_me ? 'assistant' : 'user', content: formattedText } : null;
+        })
+        .filter(message => message !== null);
+      
+      console.log(`[buildInitialMessages] Built ${formattedMessages.length} initial messages for ${code}`);
+      
+      return formattedMessages;
+    } catch (error) {
+      console.error('[buildInitialMessages] Error fetching messages:', error);
+      return [];
+    }
   }
 
   async close() {

package/lib/controllers/bugReportController.js

@@ -6,7 +6,7 @@ async function logBugReportToAirtable(reporter, whatsapp_id, description, severi
   try {
     let conversation = null;
     if (messageIds && messageIds.length > 0) {
-      const messageObjects = await Message.find({ _id: { $in: messageIds } }).sort({ timestamp: 1 });
+      const messageObjects = await Message.find({ _id: { $in: messageIds } }).sort({ createdAt: 1 });
       conversation = messageObjects.map(msg => {
         const timestamp = new Date(msg.timestamp).toISOString().slice(0, 16).replace('T', ' ');
         const role = msg.from_me ? 'Assistant' : 'Patient';

package/lib/controllers/conversationController.js

@@ -409,14 +409,14 @@ const getConversationsByNameController = async (req, res) => {
   try {
     const conversations = await Message.aggregate([
       { $match: { from_me: false, is_group: false } },
-      { $sort: { timestamp: -1 } },
+      { $sort: { createdAt: -1 } },
       { $group: {
         _id: '$numero',
         name: { $first: '$nombre_whatsapp' },
         latestMessage: { $first: '$$ROOT' },
         messageCount: { $sum: 1 }
       }},
-      { $sort: { 'latestMessage.timestamp': -1 } }
+      { $sort: { 'latestMessage.createdAt': -1 } }
     ]);
         
     res.status(200).json({

package/lib/helpers/assistantHelper.js

@@ -48,7 +48,7 @@ async function getLastMessages(code) {
       query.is_group = false;
     }
 
-    const lastMessages = await Message.find(query).sort({ timestamp: -1 });
+    const lastMessages = await Message.find(query).sort({ createdAt: -1 });
     console.log('[getLastMessages] lastMessages', lastMessages.map(msg => msg.body).join('\n\n'));
 
     if (lastMessages.length === 0) return [];
@@ -73,7 +73,7 @@ async function getLastMessages(code) {
 async function getLastNMessages(code, n) {
   try {
     const lastMessages = await Message.find({ numero: code })
-      .sort({ timestamp: -1 })
+      .sort({ createdAt: -1 })
       .limit(n);
 
     // Format each message and concatenate them with skip lines
@@ -114,20 +114,39 @@ const getPatientRoleAndName = (reply, numbers) => {
 
 function formatMessage(reply) {
   try {
-    // Validate timestamp exists
     if (!reply.timestamp) {
       return null;
     }
     
+    // Normalize timestamp: convert any format to a Date object, then to ISO string
+    let dateObj;
+    
+    if (reply.timestamp instanceof Date) {
+      dateObj = reply.timestamp;
+    } else if (typeof reply.timestamp === 'number') {
+      const ms = reply.timestamp < 1e12 ? reply.timestamp * 1000 : reply.timestamp;
+      dateObj = new Date(ms);
+    } else {
+      dateObj = new Date(reply.timestamp);
+    }
+    
+    if (isNaN(dateObj.getTime())) {
+      console.warn('[formatMessage] Invalid timestamp:', reply.timestamp);
+      return null;
+    }
+    
+    const isoString = dateObj.toISOString();
+    
     // Convert timestamp to Mexico City timezone with Spanish format
     // Format: martes, 30 de septiembre de 2025 a las 8:30 AM
-    const mexicoCityTime = moment(reply.timestamp)
+    const mexicoCityTime = moment(isoString)
       .tz('America/Mexico_City')
       .locale('es')
       .format('dddd, D [de] MMMM [de] YYYY [a las] h:mm A');
     
     return `[${mexicoCityTime}] ${reply.body}`;
-  } catch {
+  } catch (error) {
+    console.error('[formatMessage] Error formatting message:', error?.message || error, 'timestamp:', reply.timestamp);
     return null;
   } 
 }

package/lib/helpers/baileysHelper.js

@@ -110,15 +110,15 @@ async function isRecentMessage(chatId) {
 
   const recentMessage = await Message.find({
     $or: [{ group_id: chatId }, { numero: chatId }],
-    timestamp: { $gte: fiveMinutesAgo.toISOString() }
-  }).sort({ timestamp: -1 }).limit(1);
+    createdAt: { $gte: fiveMinutesAgo }
+  }).sort({ createdAt: -1 }).limit(1);
 
   return !!recentMessage;
 }
 
 async function getLastMessages(chatId, n) {
   const messages = await Message.find({ group_id: chatId })
-    .sort({ timestamp: -1 })
+    .sort({ createdAt: -1 })
     .limit(n)
     .select('timestamp numero nombre_whatsapp body');
 

package/lib/helpers/twilioHelper.js

@@ -70,8 +70,8 @@ async function isRecentMessage(chatId) {
 
   const recentMessage = await Message.find({
     $or: [{ group_id: chatId }, { numero: chatId }],
-    timestamp: { $gte: fiveMinutesAgo.toISOString() }
-  }).sort({ timestamp: -1 }).limit(1);
+    createdAt: { $gte: fiveMinutesAgo }
+  }).sort({ createdAt: -1 }).limit(1);
 
   return !!recentMessage;
 }
@@ -79,7 +79,7 @@ async function isRecentMessage(chatId) {
 
 async function getLastMessages(chatId, n) {
   const messages = await Message.find({ numero: chatId })
-    .sort({ timestamp: -1 })
+    .sort({ createdAt: -1 })
     .limit(n)
     .select('timestamp numero nombre_whatsapp body');
 

package/lib/models/messageModel.js

@@ -57,6 +57,7 @@ const messageSchema = new mongoose.Schema({
 }, { timestamps: true });
 
 messageSchema.index({ message_id: 1, timestamp: 1 }, { unique: true });
+messageSchema.index({ numero: 1, createdAt: -1 });
 
 messageSchema.pre('save', function (next) {
   if (this.timestamp) {
@@ -157,7 +158,10 @@ function getMessageValues(message, content, reply, is_media) {
 
 async function getContactDisplayName(contactNumber) {
   try {
-    const latestMessage = await Message.findOne({ numero: contactNumber })
+    const latestMessage = await Message.findOne({ 
+      numero: contactNumber,
+      from_me: false
+    })
       .sort({ createdAt: -1 })
       .select('nombre_whatsapp');
 

package/lib/providers/OpenAIAssistantsProvider.js

@@ -40,11 +40,45 @@ class OpenAIAssistantsProvider {
     return this.client;
   }
 
+  /**
+   * Retry helper for rate limit errors
+   * Extracts wait time from error message and retries with exponential backoff
+   */
+  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error?.status === 429 || error?.code === 'rate_limit_exceeded') {
+        if (retryCount >= maxRetries) {
+          throw new Error(`Rate limit exceeded after ${maxRetries} retries: ${error.message}`);
+        }
+
+        let waitTime = 60;
+        const waitMatch = error?.error?.message?.match(/after (\d+\.?\d*) seconds?/i) || 
+                         error?.message?.match(/after (\d+\.?\d*) seconds?/i);
+        if (waitMatch) {
+          waitTime = Math.ceil(parseFloat(waitMatch[1])) + 1; // Add 1 second buffer
+        } else {
+          waitTime = 60 * Math.pow(2, retryCount);
+        }
+
+        console.log(`[OpenAIAssistantsProvider] Rate limit exceeded. Waiting ${waitTime} seconds before retry ${retryCount + 1}/${maxRetries}`);
+        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+
+        return this._retryWithRateLimit(operation, maxRetries, retryCount + 1);
+      }
+
+      throw error;
+    }
+  }
+
   async createConversation({ metadata, messages = [], toolResources } = {}) {
-    const thread = await this.client.beta.threads.create({
-      metadata,
-      tool_resources: toolResources,
-    });
+    const thread = await this._retryWithRateLimit(() => 
+      this.client.beta.threads.create({
+        metadata,
+        tool_resources: toolResources,
+      })
+    );
 
     if (Array.isArray(messages) && messages.length > 0) {
       for (const message of messages) {
@@ -72,7 +106,9 @@ class OpenAIAssistantsProvider {
       delete payload.metadata;
     }
 
-    return this.client.beta.threads.messages.create(this._ensureId(threadId), payload);
+    return this._retryWithRateLimit(() => 
+      this.client.beta.threads.messages.create(this._ensureId(threadId), payload)
+    );
   }
 
   async listMessages({ threadId, runId, order = 'desc', limit } = {}) {
@@ -153,7 +189,9 @@ class OpenAIAssistantsProvider {
       }
     });
 
-    return this.client.beta.threads.runs.create(this._ensureId(threadId), payload);
+    return this._retryWithRateLimit(() => 
+      this.client.beta.threads.runs.create(this._ensureId(threadId), payload)
+    );
   }
 
   async getRun({ threadId, runId }) {

package/lib/providers/OpenAIResponsesProvider.js

@@ -3,6 +3,9 @@ const { OpenAI } = require('openai');
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
+const MAX_ITEMS_ON_CREATE = 20;
+const MAX_ITEMS_PER_BATCH = 20;
+const DEFAULT_MAX_HISTORICAL_MESSAGES = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
 
 /**
  * Provider wrapper that targets the Conversations + Responses API surface.
@@ -43,21 +46,153 @@ class OpenAIResponsesProvider {
     return this.client;
   }
 
+  /**
+   * Retry helper for rate limit errors
+   * Extracts wait time from error message and retries with exponential backoff
+   */
+  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error?.status === 429 || error?.code === 'rate_limit_exceeded') {
+        if (retryCount >= maxRetries) {
+          throw new Error(`Rate limit exceeded after ${maxRetries} retries: ${error.message}`);
+        }
+
+        let waitTime = 60;
+        const waitMatch = error?.error?.message?.match(/after (\d+\.?\d*) seconds?/i) || 
+                         error?.message?.match(/after (\d+\.?\d*) seconds?/i);
+        if (waitMatch) {
+          waitTime = Math.ceil(parseFloat(waitMatch[1])) + 1; // Add 1 second buffer
+        } else {
+          waitTime = 60 * Math.pow(2, retryCount);
+        }
+
+        console.log(`[OpenAIResponsesProvider] Rate limit exceeded. Waiting ${waitTime} seconds before retry ${retryCount + 1}/${maxRetries}`);
+        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+
+        return this._retryWithRateLimit(operation, maxRetries, retryCount + 1);
+      }
+
+      throw error;
+    }
+  }
+
   /**
    * Conversations helpers
    */
   async createConversation({ metadata, messages = [], toolResources } = {}) {
+    const messagesToProcess = messages.length > DEFAULT_MAX_HISTORICAL_MESSAGES 
+      ? messages.slice(-DEFAULT_MAX_HISTORICAL_MESSAGES)
+      : messages;
+    
+    if (messages.length > DEFAULT_MAX_HISTORICAL_MESSAGES) {
+      console.warn(`[OpenAIResponsesProvider] Capped ${messages.length} → ${DEFAULT_MAX_HISTORICAL_MESSAGES} messages`);
+    }
+    
+    const allItems = this._conversationItems(messagesToProcess);
+    const totalItems = allItems.length;
+    
+    // Create empty conversation if no messages
+    if (totalItems === 0) {
+      const payload = this._cleanObject({
+        metadata,
+        tool_resources: toolResources,
+      });
+      
+      return this._retryWithRateLimit(async () => {
+        if (this.conversations && typeof this.conversations.create === 'function') {
+          return await this.conversations.create(payload);
+        }
+        return await this._post('/conversations', payload);
+      });
+    }
+    
+    // Split items: first batch for initial creation, rest to add in batches
+    const initialItems = allItems.slice(0, MAX_ITEMS_ON_CREATE);
+    const remainingItems = allItems.slice(MAX_ITEMS_ON_CREATE);
+    const totalBatches = Math.ceil(remainingItems.length / MAX_ITEMS_PER_BATCH);
+    
+    // Concise batch summary
+    console.log(`[OpenAIResponsesProvider] Batching: ${initialItems.length} (create) + ${remainingItems.length} (${totalBatches} batches) = ${totalItems} total`);
+
     const payload = this._cleanObject({
       metadata,
-      items: this._conversationItems(messages),
+      items: initialItems,
       tool_resources: toolResources,
     });
 
-    if (this.conversations && typeof this.conversations.create === 'function') {
-      return await this.conversations.create(payload);
+    let conversation;
+    try {
+      conversation = await this._retryWithRateLimit(async () => {
+        if (this.conversations && typeof this.conversations.create === 'function') {
+          return await this.conversations.create(payload);
+        }
+        return await this._post('/conversations', payload);
+      });
+    } catch (error) {
+      console.error('[OpenAIResponsesProvider] Failed to create conversation:', error?.message || error);
+      throw error;
+    }
+
+    // Add remaining messages in batches (maintains chronological order)
+    if (remainingItems.length > 0) {
+      try {
+        await this._addItemsInBatches(conversation.id, remainingItems);
+      } catch (error) {
+        console.error('[OpenAIResponsesProvider] Failed to add remaining messages. Conversation created with partial history:', error?.message || error);
+      }
+    }
+
+    return conversation;
+  }
+
+  /**
+   * Add items to a conversation in batches
+   * Items are converted to API format with type: 'message' for the items.create endpoint
+   * @private
+   */
+  async _addItemsInBatches(threadId, items, batchSize = MAX_ITEMS_PER_BATCH) {
+    if (!items || items.length === 0) {
+      return;
+    }
+
+    const id = this._ensurethreadId(threadId);
+    const totalBatches = Math.ceil(items.length / batchSize);
+    
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const batchNumber = Math.floor(i / batchSize) + 1;
+      
+      const batchPayload = this._convertItemsToApiFormat(batch);
+
+      try {
+        await this._retryWithRateLimit(async () => {
+          if (this.conversations?.items?.create) {
+            return await this.conversations.items.create(id, { items: batchPayload });
+          }
+          return await this._post(`/conversations/${id}/items`, { items: batchPayload });
+        });
+      } catch (error) {
+        console.error(`[OpenAIResponsesProvider] Batch ${batchNumber}/${totalBatches} failed:`, error?.message || error);
+        throw error;
+      }
     }
+    
+    console.log(`[OpenAIResponsesProvider] Successfully added ${items.length} messages in ${totalBatches} batches`);
+  }
 
-    return await this._post('/conversations', payload);
+  /**
+   * Convert conversation items to API format for items.create endpoint
+   * Adds type: 'message' which is required by the items.create API
+   * @private
+   */
+  _convertItemsToApiFormat(items) {
+    return items.map(item => ({
+      role: item.role,
+      content: item.content,
+      type: 'message',
+    }));
   }
 
   async deleteConversation(threadId) {
@@ -79,10 +214,12 @@ class OpenAIResponsesProvider {
     console.log('payload', payload);
 
     if (payload.content) {
-      if (this.conversations?.items?.create) {
-        return await this.conversations.items.create(id, {items: [payload]});
-      }
-      return await this._post(`/conversations/${id}/items`, {items: [payload]});
+      return this._retryWithRateLimit(async () => {
+        if (this.conversations?.items?.create) {
+          return await this.conversations.items.create(id, {items: [payload]});
+        }
+        return await this._post(`/conversations/${id}/items`, {items: [payload]});
+      });
     }
   }
 
@@ -159,7 +296,9 @@ class OpenAIResponsesProvider {
       });
 
       console.log('payload', payload);
-      const response = await this.client.responses.create(payload);
+      const response = await this._retryWithRateLimit(() => 
+        this.client.responses.create(payload)
+      );
       console.log('response', response);
 
       if (response?.status !== 'completed') {

package/package.json

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