@peopl-health/nexus 1.0.2

package/lib/storage/MongoStorage.js

@@ -0,0 +1,183 @@
+const mongoose = require('mongoose');
+
+/**
+ * MongoDB storage interface for messages and interactions
+ */
+class MongoStorage {
+  constructor(config) {
+    this.mongoUri = config.mongoUri;
+    this.dbName = config.dbName;
+    this.collections = config.collections || {
+      messages: 'messages',
+      interactions: 'interactions',
+      threads: 'threads'
+    };
+    this.schemas = this.createSchemas();
+  }
+
+  createSchemas() {
+    const messageSchema = new mongoose.Schema({
+      messageId: String,
+      numero: String,
+      body: String,
+      timestamp: String,
+      isGroup: { type: Boolean, default: false },
+      isMedia: { type: Boolean, default: false },
+      fromMe: { type: Boolean, default: false },
+      contentSid: String,
+      isTemplate: { type: Boolean, default: false },
+      templateVariables: String,
+      provider: String,
+      createdAt: { type: Date, default: Date.now }
+    });
+
+    const interactionSchema = new mongoose.Schema({
+      messageId: String,
+      numero: String,
+      interactionType: String, // 'button', 'list', 'flow'
+      payload: mongoose.Schema.Types.Mixed,
+      timestamp: String,
+      createdAt: { type: Date, default: Date.now }
+    });
+
+    const threadSchema = new mongoose.Schema({
+      code: String,
+      assistantId: String,
+      threadId: String,
+      patientId: String,
+      runId: String,
+      nombre: String,
+      active: { type: Boolean, default: true },
+      stopped: { type: Boolean, default: false },
+      nextSid: [String],
+      createdAt: { type: Date, default: Date.now }
+    });
+
+    return {
+      Message: mongoose.model('Message', messageSchema),
+      Interaction: mongoose.model('Interaction', interactionSchema),
+      Thread: mongoose.model('Thread', threadSchema)
+    };
+  }
+
+  async connect() {
+    try {
+      await mongoose.connect(this.mongoUri, {
+        useNewUrlParser: true,
+        useUnifiedTopology: true
+      });
+      console.log('MongoDB connected successfully');
+    } catch (error) {
+      throw new Error(`MongoDB connection failed: ${error.message}`);
+    }
+  }
+
+  async saveMessage(messageData) {
+    try {
+      const message = new this.schemas.Message({
+        messageId: messageData.messageId,
+        numero: messageData.to || messageData.from,
+        body: messageData.message || messageData.body,
+        timestamp: this.formatTimestamp(messageData.timestamp),
+        isGroup: messageData.isGroup || false,
+        isMedia: messageData.fileType && messageData.fileType !== 'text',
+        fromMe: messageData.fromMe || false,
+        contentSid: messageData.contentSid,
+        isTemplate: !!messageData.contentSid,
+        templateVariables: messageData.variables ? JSON.stringify(messageData.variables) : null,
+        provider: messageData.provider
+      });
+
+      await message.save();
+      return message;
+    } catch (error) {
+      console.error('Error saving message:', error);
+      throw error;
+    }
+  }
+
+  async saveInteractive(interactionData) {
+    try {
+      const interaction = new this.schemas.Interaction({
+        messageId: interactionData.messageId,
+        numero: interactionData.from,
+        interactionType: interactionData.type, // 'button', 'list', 'flow'
+        payload: interactionData.payload,
+        timestamp: this.formatTimestamp(interactionData.timestamp)
+      });
+
+      await interaction.save();
+      return interaction;
+    } catch (error) {
+      console.error('Error saving interaction:', error);
+      throw error;
+    }
+  }
+
+  async getMessages(numero, limit = 50) {
+    try {
+      return await this.schemas.Message
+        .find({ numero })
+        .sort({ createdAt: -1 })
+        .limit(limit);
+    } catch (error) {
+      console.error('Error getting messages:', error);
+      throw error;
+    }
+  }
+
+  async getThread(code) {
+    try {
+      return await this.schemas.Thread.findOne({ code, active: true });
+    } catch (error) {
+      console.error('Error getting thread:', error);
+      throw error;
+    }
+  }
+
+  async createThread(threadData) {
+    try {
+      const thread = new this.schemas.Thread(threadData);
+      await thread.save();
+      return thread;
+    } catch (error) {
+      console.error('Error creating thread:', error);
+      throw error;
+    }
+  }
+
+  async updateThread(code, updateData) {
+    try {
+      return await this.schemas.Thread.findOneAndUpdate(
+        { code },
+        { $set: updateData },
+        { new: true }
+      );
+    } catch (error) {
+      console.error('Error updating thread:', error);
+      throw error;
+    }
+  }
+
+  formatTimestamp(timestamp) {
+    if (!timestamp) timestamp = new Date();
+    const date = new Date(timestamp);
+    const mexicoTime = new Date(date.getTime() - (6 * 60 * 60 * 1000));
+    
+    return mexicoTime.getUTCFullYear() + '-' + 
+           String(mexicoTime.getUTCMonth() + 1).padStart(2, '0') + '-' + 
+           String(mexicoTime.getUTCDate()).padStart(2, '0') + ' ' + 
+           String(mexicoTime.getUTCHours()).padStart(2, '0') + ':' + 
+           String(mexicoTime.getUTCMinutes()).padStart(2, '0') + ':' + 
+           String(mexicoTime.getUTCSeconds()).padStart(2, '0');
+  }
+
+  async disconnect() {
+    await mongoose.disconnect();
+    if (this.client) {
+      await this.client.close();
+    }
+  }
+}
+
+module.exports = { MongoStorage };

package/lib/storage/index.js

@@ -0,0 +1,5 @@
+const { MongoStorage } = require('./MongoStorage');
+
+module.exports = {
+  MongoStorage
+};

package/lib/utils/AssistantManager.js

@@ -0,0 +1,218 @@
+/**
+ * Configurable assistant manager for handling AI interactions
+ */
+class AssistantManager {
+  constructor(config = {}) {
+    this.config = config;
+    this.assistants = new Map();
+    this.llmClient = null;
+    this.handlers = {
+      onRequiresAction: null,
+      onCompleted: null,
+      onFailed: null
+    };
+  }
+
+  /**
+   * Initialize with LLM client (OpenAI, etc.)
+   * @param {Object} llmClient - LLM client instance
+   */
+  setLLMClient(llmClient) {
+    this.llmClient = llmClient;
+  }
+
+  /**
+   * Register assistant configurations
+   * @param {Object} assistantConfigs - Map of assistant IDs to configurations
+   */
+  registerAssistants(assistantConfigs) {
+    Object.entries(assistantConfigs).forEach(([key, config]) => {
+      this.assistants.set(key, config);
+    });
+  }
+
+  /**
+   * Set event handlers for assistant interactions
+   * @param {Object} handlers - Handler functions
+   */
+  setHandlers(handlers) {
+    this.handlers = { ...this.handlers, ...handlers };
+  }
+
+  /**
+   * Create a new thread for a conversation
+   * @param {string} code - User/conversation identifier
+   * @param {string} assistantId - Assistant ID to use
+   * @param {Array} initialMessages - Initial messages for context
+   */
+  async createThread(code, assistantId, initialMessages = []) {
+    if (!this.llmClient) {
+      throw new Error('LLM client not configured');
+    }
+
+    try {
+      const thread = await this.llmClient.beta.threads.create();
+      
+      // Add initial messages if provided
+      for (const message of initialMessages) {
+        await this.llmClient.beta.threads.messages.create(
+          thread.id, 
+          { role: 'assistant', content: message }
+        );
+      }
+
+      return {
+        code,
+        assistantId,
+        threadId: thread.id,
+        active: true,
+        createdAt: new Date()
+      };
+    } catch (error) {
+      throw new Error(`Failed to create thread: ${error.message}`);
+    }
+  }
+
+  /**
+   * Send message to assistant and get response
+   * @param {Object} threadData - Thread information
+   * @param {string} message - User message
+   * @param {Object} runOptions - Additional run options
+   */
+  async sendMessage(threadData, message, runOptions = {}) {
+    if (!this.llmClient) {
+      throw new Error('LLM client not configured');
+    }
+
+    try {
+      // Add user message to thread
+      await this.llmClient.beta.threads.messages.create(
+        threadData.threadId,
+        { role: 'user', content: message }
+      );
+
+      // Create run
+      const run = await this.llmClient.beta.threads.runs.create(
+        threadData.threadId,
+        {
+          assistant_id: threadData.assistantId,
+          ...runOptions
+        }
+      );
+
+      // Wait for completion and handle actions
+      const result = await this.waitForCompletion(threadData.threadId, run.id);
+      
+      if (result.status === 'completed') {
+        const messages = await this.llmClient.beta.threads.messages.list(
+          threadData.threadId, 
+          { run_id: run.id }
+        );
+        return messages.data[0]?.content[0]?.text?.value || '';
+      } else if (result.status === 'requires_action') {
+        if (this.handlers.onRequiresAction) {
+          return await this.handlers.onRequiresAction(result, threadData);
+        }
+      }
+
+      return null;
+    } catch (error) {
+      throw new Error(`Assistant interaction failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Wait for run completion and handle different statuses
+   * @param {string} threadId - Thread ID
+   * @param {string} runId - Run ID
+   */
+  async waitForCompletion(threadId, runId) {
+    const maxAttempts = 30;
+    let attempts = 0;
+
+    while (attempts < maxAttempts) {
+      const run = await this.llmClient.beta.threads.runs.retrieve(threadId, runId);
+      
+      if (run.status === 'completed') {
+        return { status: 'completed', run };
+      } else if (run.status === 'requires_action') {
+        return { status: 'requires_action', run };
+      } else if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
+        if (this.handlers.onFailed) {
+          await this.handlers.onFailed(run);
+        }
+        return { status: 'failed', run };
+      }
+
+      // Wait before next check
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      attempts++;
+    }
+
+    throw new Error('Assistant run timeout');
+  }
+
+  /**
+   * Submit tool outputs for function calls
+   * @param {string} threadId - Thread ID
+   * @param {string} runId - Run ID
+   * @param {Array} toolOutputs - Tool outputs array
+   */
+  async submitToolOutputs(threadId, runId, toolOutputs) {
+    if (!this.llmClient) {
+      throw new Error('LLM client not configured');
+    }
+
+    try {
+      const run = await this.llmClient.beta.threads.runs.submitToolOutputs(
+        threadId,
+        runId,
+        { tool_outputs: toolOutputs }
+      );
+
+      return await this.waitForCompletion(threadId, run.id);
+    } catch (error) {
+      throw new Error(`Failed to submit tool outputs: ${error.message}`);
+    }
+  }
+
+  /**
+   * Add instruction to existing thread
+   * @param {Object} threadData - Thread information
+   * @param {string} instruction - Additional instruction
+   */
+  async addInstruction(threadData, instruction) {
+    if (!this.llmClient) {
+      throw new Error('LLM client not configured');
+    }
+
+    try {
+      const run = await this.llmClient.beta.threads.runs.create(
+        threadData.threadId,
+        {
+          assistant_id: threadData.assistantId,
+          additional_instructions: instruction,
+          additional_messages: [
+            { role: 'user', content: instruction }
+          ]
+        }
+      );
+
+      const result = await this.waitForCompletion(threadData.threadId, run.id);
+      
+      if (result.status === 'completed') {
+        const messages = await this.llmClient.beta.threads.messages.list(
+          threadData.threadId, 
+          { run_id: run.id }
+        );
+        return messages.data[0]?.content[0]?.text?.value || '';
+      }
+
+      return null;
+    } catch (error) {
+      throw new Error(`Failed to add instruction: ${error.message}`);
+    }
+  }
+}
+
+module.exports = { AssistantManager };

package/lib/utils/DefaultLLMProvider.js

@@ -0,0 +1,22 @@
+const { OpenAI } = require('openai');
+
+/**
+ * Default LLM Provider using OpenAI
+ */
+class DefaultLLMProvider {
+  constructor(config = {}) {
+    const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+    
+    if (!apiKey) {
+      throw new Error('OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.');
+    }
+
+    this.client = new OpenAI({ apiKey });
+  }
+
+  getClient() {
+    return this.client;
+  }
+}
+
+module.exports = { DefaultLLMProvider };

package/lib/utils/MessageParser.js

@@ -0,0 +1,249 @@
+/**
+ * Configurable message parser for different message types
+ */
+class MessageParser {
+  constructor(config = {}) {
+    this.config = config;
+    this.commandPrefixes = config.commandPrefixes || ['/', '!'];
+    this.keywords = config.keywords || [];
+    this.flowTriggers = config.flowTriggers || [];
+  }
+
+  /**
+   * Parse incoming message and determine its type
+   * @param {Object} rawMessage - Raw message from provider
+   * @returns {Object} Parsed message with type and data
+   */
+  parseMessage(rawMessage) {
+    const messageData = {
+      id: rawMessage.id || rawMessage.key?.id,
+      from: this.extractSender(rawMessage),
+      timestamp: rawMessage.timestamp || Date.now(),
+      raw: rawMessage
+    };
+
+    // Check for interactive messages (buttons, lists, flows)
+    if (this.isInteractiveMessage(rawMessage)) {
+      return {
+        ...messageData,
+        type: 'interactive',
+        interactive: this.parseInteractive(rawMessage)
+      };
+    }
+
+    // Check for media messages
+    if (this.isMediaMessage(rawMessage)) {
+      return {
+        ...messageData,
+        type: 'media',
+        media: this.parseMedia(rawMessage)
+      };
+    }
+
+    // Parse text content
+    const textContent = this.extractTextContent(rawMessage);
+    if (!textContent) {
+      return { ...messageData, type: 'unknown' };
+    }
+
+    messageData.message = textContent;
+
+    // Check for commands
+    if (this.isCommand(textContent)) {
+      return {
+        ...messageData,
+        type: 'command',
+        command: this.parseCommand(textContent)
+      };
+    }
+
+    // Check for keywords
+    const keyword = this.findKeyword(textContent);
+    if (keyword) {
+      return {
+        ...messageData,
+        type: 'keyword',
+        keyword: keyword
+      };
+    }
+
+    // Check for flow triggers
+    const flowTrigger = this.findFlowTrigger(textContent);
+    if (flowTrigger) {
+      return {
+        ...messageData,
+        type: 'flow',
+        flow: flowTrigger
+      };
+    }
+
+    // Default to regular message
+    return {
+      ...messageData,
+      type: 'message'
+    };
+  }
+
+  extractSender(rawMessage) {
+    // Twilio format
+    if (rawMessage.From) {
+      return rawMessage.From;
+    }
+    
+    // Baileys format
+    if (rawMessage.key?.remoteJid) {
+      return rawMessage.key.remoteJid;
+    }
+
+    return null;
+  }
+
+  extractTextContent(rawMessage) {
+    // Twilio format
+    if (rawMessage.Body) {
+      return rawMessage.Body;
+    }
+
+    // Baileys format
+    if (rawMessage.message?.conversation) {
+      return rawMessage.message.conversation;
+    }
+
+    if (rawMessage.message?.extendedTextMessage?.text) {
+      return rawMessage.message.extendedTextMessage.text;
+    }
+
+    return null;
+  }
+
+  isInteractiveMessage(rawMessage) {
+    // Twilio interactive messages
+    return !!(rawMessage.ButtonPayload || rawMessage.ListId || rawMessage.FlowData || rawMessage.InteractiveData);
+  }
+
+  parseInteractive(rawMessage) {
+    if (rawMessage.ButtonPayload) {
+      return {
+        type: 'button',
+        payload: rawMessage.ButtonPayload,
+        title: rawMessage.ButtonText
+      };
+    }
+
+    if (rawMessage.ListId) {
+      return {
+        type: 'list',
+        id: rawMessage.ListId,
+        title: rawMessage.ListTitle,
+        description: rawMessage.ListDescription
+      };
+    }
+
+    if (rawMessage.FlowData || rawMessage.InteractiveData) {
+      return {
+        type: 'flow',
+        data: rawMessage.FlowData || rawMessage.InteractiveData
+      };
+    }
+
+    return null;
+  }
+
+  isMediaMessage(rawMessage) {
+    // Twilio format
+    if (rawMessage.NumMedia && parseInt(rawMessage.NumMedia) > 0) {
+      return true;
+    }
+
+    // Baileys format
+    if (rawMessage.message) {
+      const messageTypes = Object.keys(rawMessage.message);
+      return messageTypes.some(type => 
+        type.match(/(image|audio|video|document)/)
+      );
+    }
+
+    return false;
+  }
+
+  parseMedia(rawMessage) {
+    // Twilio format
+    if (rawMessage.MediaUrl0) {
+      return {
+        url: rawMessage.MediaUrl0,
+        contentType: rawMessage.MediaContentType0,
+        filename: rawMessage.MediaFilename0
+      };
+    }
+
+    // Baileys format - would need additional processing
+    if (rawMessage.message) {
+      const messageTypes = Object.keys(rawMessage.message);
+      const mediaType = messageTypes.find(type => 
+        type.match(/(image|audio|video|document)/)
+      );
+      
+      if (mediaType) {
+        return {
+          type: mediaType,
+          data: rawMessage.message[mediaType]
+        };
+      }
+    }
+
+    return null;
+  }
+
+  isCommand(text) {
+    return this.commandPrefixes.some(prefix => text.startsWith(prefix));
+  }
+
+  parseCommand(text) {
+    const prefix = this.commandPrefixes.find(p => text.startsWith(p));
+    const commandText = text.substring(prefix.length).trim();
+    const parts = commandText.split(' ');
+    
+    return {
+      prefix,
+      command: parts[0],
+      args: parts.slice(1)
+    };
+  }
+
+  findKeyword(text) {
+    const lowerText = text.toLowerCase();
+    return this.keywords.find(keyword => {
+      if (typeof keyword === 'string') {
+        return lowerText.includes(keyword.toLowerCase());
+      } else if (keyword.pattern) {
+        return new RegExp(keyword.pattern, 'i').test(text);
+      }
+      return false;
+    });
+  }
+
+  findFlowTrigger(text) {
+    const lowerText = text.toLowerCase();
+    return this.flowTriggers.find(trigger => {
+      if (typeof trigger === 'string') {
+        return lowerText.includes(trigger.toLowerCase());
+      } else if (trigger.pattern) {
+        return new RegExp(trigger.pattern, 'i').test(text);
+      }
+      return false;
+    });
+  }
+
+  /**
+   * Update parser configuration
+   * @param {Object} newConfig - New configuration
+   */
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    this.commandPrefixes = this.config.commandPrefixes || this.commandPrefixes;
+    this.keywords = this.config.keywords || this.keywords;
+    this.flowTriggers = this.config.flowTriggers || this.flowTriggers;
+  }
+}
+
+module.exports = { MessageParser };

package/lib/utils/index.js

@@ -0,0 +1,22 @@
+const { MessageParser } = require('./MessageParser');
+const { DefaultLLMProvider } = require('./DefaultLLMProvider');
+const { logger, createLogger } = require('./logger');
+const { delay, formatCode, calculateDelay } = require('./whatsappHelper');
+const { useMongoDBAuthState } = require('./mongoAuthConfig');
+const { convertTwilioToInternalFormat, downloadMediaFromTwilio, getMediaTypeFromContentType, extractTitle, ensureWhatsAppFormat } = require('./twilioHelper');
+
+module.exports = {
+  MessageParser,
+  DefaultLLMProvider,
+  logger,
+  createLogger,
+  delay,
+  formatCode,
+  calculateDelay,
+  useMongoDBAuthState,
+  convertTwilioToInternalFormat,
+  downloadMediaFromTwilio,
+  getMediaTypeFromContentType,
+  extractTitle,
+  ensureWhatsAppFormat
+};