@peopl-health/nexus 1.0.2

package/lib/index.d.ts

@@ -0,0 +1,276 @@
+declare module '@peopl/nexus' {
+  import { EventEmitter } from 'events';
+  import mongoose from 'mongoose';
+
+  // Core Types
+  export interface MessageData {
+    id?: string;
+    from: string;
+    to?: string;
+    message?: string;
+    fileUrl?: string;
+    fileType?: 'text' | 'image' | 'document' | 'audio' | 'video';
+    contentSid?: string;
+    variables?: Record<string, string>;
+    timestamp?: Date;
+    interactive?: InteractiveData;
+    media?: MediaData;
+    command?: CommandData;
+    keyword?: string;
+    flow?: string;
+    type?: 'message' | 'interactive' | 'media' | 'command' | 'keyword' | 'flow';
+  }
+
+  export interface InteractiveData {
+    type: 'button' | 'list' | 'flow';
+    payload?: string;
+    title?: string;
+    description?: string;
+    data?: any;
+  }
+
+  export interface MediaData {
+    url?: string;
+    contentType?: string;
+    filename?: string;
+    type?: string;
+    data?: any;
+  }
+
+  export interface CommandData {
+    prefix: string;
+    command: string;
+    args: string[];
+  }
+
+  export interface ScheduledMessage extends MessageData {
+    sendTime: string | Date;
+    timeZone?: string;
+  }
+
+  export interface ThreadData {
+    code: string;
+    assistantId: string;
+    threadId: string;
+    patientId?: string;
+    runId?: string;
+    nombre?: string;
+    active: boolean;
+    stopped?: boolean;
+    nextSid?: string[];
+    createdAt: Date;
+  }
+
+  // Provider Configurations
+  export interface TwilioConfig {
+    accountSid: string;
+    authToken: string;
+    whatsappNumber: string;
+  }
+
+  export interface BaileysConfig {
+    authState?: string;
+    mongoUri?: string;
+    userDbMongo?: string;
+  }
+
+  export interface StorageConfig {
+    mongoUri: string;
+    dbName: string;
+    collections?: {
+      messages?: string;
+      interactions?: string;
+      threads?: string;
+    };
+  }
+
+  export interface AssistantConfig {
+    llmClient?: any;
+    assistants?: Record<string, string>;
+    handlers?: {
+      onRequiresAction?: (result: any, threadData: ThreadData) => Promise<any>;
+      onCompleted?: (result: any) => Promise<void>;
+      onFailed?: (result: any) => Promise<void>;
+    };
+  }
+
+  export interface ParserConfig {
+    commandPrefixes?: string[];
+    keywords?: (string | { pattern: string; flags?: string })[];
+    flowTriggers?: (string | { pattern: string; flags?: string })[];
+  }
+
+  // Handler Types
+  export type MessageHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+  export type InteractiveHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+  export type MediaHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+  export type CommandHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+  export type KeywordHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+  export type FlowHandler = (messageData: MessageData, nexus: Nexus) => Promise<void>;
+
+  export interface MessageHandlers {
+    onMessage?: MessageHandler;
+    onInteractive?: InteractiveHandler;
+    onMedia?: MediaHandler;
+    onCommand?: CommandHandler;
+    onKeyword?: KeywordHandler;
+    onFlow?: FlowHandler;
+  }
+
+  // Core Classes
+  export abstract class MessageProvider {
+    constructor(config: any);
+    abstract initialize(): Promise<void>;
+    abstract sendMessage(messageData: MessageData): Promise<any>;
+    abstract sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
+    abstract getConnectionStatus(): boolean;
+    abstract disconnect(): Promise<void>;
+  }
+
+  export class TwilioProvider extends MessageProvider {
+    constructor(config: TwilioConfig);
+    initialize(): Promise<void>;
+    sendMessage(messageData: MessageData): Promise<any>;
+    sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
+    getConnectionStatus(): boolean;
+    disconnect(): Promise<void>;
+  }
+
+  export class BaileysProvider extends MessageProvider {
+    constructor(config: BaileysConfig);
+    initialize(): Promise<void>;
+    sendMessage(messageData: MessageData): Promise<any>;
+    sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
+    getConnectionStatus(): boolean;
+    disconnect(): Promise<void>;
+  }
+
+  export class NexusMessaging {
+    constructor(config?: any);
+    initializeProvider(providerType: 'twilio' | 'baileys', providerConfig: TwilioConfig | BaileysConfig): Promise<void>;
+    setMessageStorage(storage: any): void;
+    setHandlers(handlers: MessageHandlers): void;
+    sendMessage(messageData: MessageData): Promise<any>;
+    sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
+    processIncomingMessage(messageData: MessageData): Promise<any>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+  }
+
+  export class MongoStorage {
+    constructor(config: StorageConfig);
+    connect(): Promise<void>;
+    saveMessage(messageData: MessageData): Promise<any>;
+    saveInteractive(interactionData: any): Promise<any>;
+    getMessages(numero: string, limit?: number): Promise<any[]>;
+    getThread(code: string): Promise<ThreadData | null>;
+    createThread(threadData: ThreadData): Promise<ThreadData>;
+    updateThread(code: string, updateData: Partial<ThreadData>): Promise<ThreadData | null>;
+    disconnect(): Promise<void>;
+  }
+
+  export class AssistantManager {
+    constructor(config?: AssistantConfig);
+    setLLMClient(llmClient: any): void;
+    registerAssistants(assistantConfigs: Record<string, string>): void;
+    setHandlers(handlers: AssistantConfig['handlers']): void;
+    createThread(code: string, assistantId: string, initialMessages?: string[]): Promise<ThreadData>;
+    sendMessage(threadData: ThreadData, message: string, runOptions?: any): Promise<string | null>;
+    submitToolOutputs(threadId: string, runId: string, toolOutputs: any[]): Promise<any>;
+    addInstruction(threadData: ThreadData, instruction: string): Promise<string | null>;
+  }
+
+  export class MessageParser {
+    constructor(config?: ParserConfig);
+    parseMessage(rawMessage: any): MessageData;
+    updateConfig(newConfig: ParserConfig): void;
+  }
+
+  // Main Nexus Class
+  export interface NexusConfig {
+    messaging?: any;
+  }
+
+  export interface InitializeOptions {
+    provider?: 'twilio' | 'baileys';
+    providerConfig?: TwilioConfig | BaileysConfig;
+    storage?: 'mongo';
+    storageConfig?: StorageConfig;
+    assistant?: AssistantConfig;
+    parser?: boolean;
+    parserConfig?: ParserConfig;
+  }
+
+  export class Nexus {
+    constructor(config?: NexusConfig);
+    initialize(options?: InitializeOptions): Promise<void>;
+    setHandlers(handlers: MessageHandlers): void;
+    sendMessage(messageData: MessageData): Promise<any>;
+    sendScheduledMessage(scheduledMessage: ScheduledMessage): Promise<void>;
+    processMessage(rawMessage: any): Promise<any>;
+    createAssistantThread(code: string, assistantId: string, initialMessages?: string[]): Promise<ThreadData>;
+    sendToAssistant(code: string, message: string, runOptions?: any): Promise<string | null>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    getMessaging(): NexusMessaging;
+    getStorage(): MongoStorage | null;
+    getAssistantManager(): AssistantManager | null;
+    getMessageParser(): MessageParser | null;
+  }
+
+  // Utility Functions
+  export function createLogger(config?: any): any;
+  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 convertTwilioToInternalFormat(twilioMessage: any): any;
+  export function downloadMediaFromTwilio(mediaUrl: string, credentials: any): Promise<Buffer>;
+  export function getMediaTypeFromContentType(contentType: string): string;
+  export function extractTitle(message: any, mediaType: string): string | null;
+  export function useMongoDBAuthState(uri: string, dbName: string, sessionId: string): Promise<any>;
+
+  // 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 formatTimestamp(unixTimestamp: number): string;
+
+  // Module Exports
+  export const adapters: {
+    TwilioProvider: typeof TwilioProvider;
+    BaileysProvider: typeof BaileysProvider;
+  };
+
+  export const core: {
+    NexusMessaging: typeof NexusMessaging;
+    MessageProvider: typeof MessageProvider;
+  };
+
+  export const storage: {
+    MongoStorage: typeof MongoStorage;
+  };
+
+  export const utils: {
+    AssistantManager: typeof AssistantManager;
+    MessageParser: typeof MessageParser;
+    logger: any;
+    createLogger: typeof createLogger;
+    delay: typeof delay;
+    formatCode: typeof formatCode;
+    calculateDelay: typeof calculateDelay;
+    useMongoDBAuthState: typeof useMongoDBAuthState;
+    convertTwilioToInternalFormat: typeof convertTwilioToInternalFormat;
+    downloadMediaFromTwilio: typeof downloadMediaFromTwilio;
+    getMediaTypeFromContentType: typeof getMediaTypeFromContentType;
+    extractTitle: typeof extractTitle;
+    ensureWhatsAppFormat: typeof ensureWhatsAppFormat;
+  };
+
+  export const models: {
+    Message: typeof Message;
+    Thread: typeof Thread;
+    getMessageValues: typeof getMessageValues;
+    formatTimestamp: typeof formatTimestamp;
+  };
+}

package/lib/index.js

@@ -0,0 +1,204 @@
+const { NexusMessaging } = require('./core/NexusMessaging');
+const { TwilioProvider } = require('./adapters/TwilioProvider');
+const { BaileysProvider } = require('./adapters/BaileysProvider');
+const { MongoStorage } = require('./storage/MongoStorage');
+const { MessageParser } = require('./utils/MessageParser');
+const { DefaultLLMProvider } = require('./utils/DefaultLLMProvider');
+
+// Export individual components
+const adapters = require('./adapters');
+const core = require('./core');
+const storage = require('./storage');
+const utils = require('./utils');
+const models = require('./models');
+
+/**
+ * Main Nexus class that orchestrates all components
+ */
+class Nexus {
+  constructor(config = {}) {
+    this.config = config;
+    this.messaging = new NexusMessaging(config.messaging || {});
+    this.storage = null;
+    this.messageParser = null;
+    this.llmProvider = null;
+    this.isInitialized = false;
+  }
+
+  /**
+   * Initialize Nexus with providers and storage
+   * @param {Object} options - Initialization options
+   * @param {string} [options.provider='twilio'] - Messaging provider ('twilio' or 'baileys')
+   * @param {Object} [options.providerConfig={}] - Provider-specific configuration
+   * @param {string} [options.storage='mongo'] - Storage type ('mongo' or false)
+   * @param {Object} [options.storageConfig={}] - Storage configuration
+   * @param {string} [options.parser='MessageParser'] - Message parser type
+   * @param {Object} [options.parserConfig={}] - Parser configuration
+   * @param {string} [options.llm='openai'] - LLM provider type
+   * @param {Object} [options.llmConfig={}] - LLM configuration
+   * @returns {Promise<void>}
+   */
+  async initialize(options = {}) {
+    const {
+      provider = 'twilio',
+      providerConfig = {},
+      storage = 'mongo',
+      storageConfig = {},
+      parser = 'MessageParser',
+      parserConfig = {},
+      llm = 'openai',
+      llmConfig = {}
+    } = options;
+
+    // Initialize messaging provider
+    await this.messaging.initializeProvider(provider, providerConfig);
+
+    // Initialize storage if provided
+    if (storage === 'mongo') {
+      this.storage = new MongoStorage(storageConfig);
+      await this.storage.connect();
+      this.messaging.setMessageStorage(this.storage);
+    }
+
+    // Initialize message parser if provided
+    if (parser !== false) {
+      this.messageParser = new MessageParser(parserConfig);
+    }
+
+    // Initialize default LLM provider if requested
+    if (llm === 'openai') {
+      this.llmProvider = new DefaultLLMProvider(llmConfig);
+    }
+
+    this.isInitialized = true;
+  }
+
+  /**
+   * Set message handlers for different types
+   * @param {Object} handlers - Handler functions
+   */
+  setHandlers(handlers) {
+    this.messaging.setHandlers(handlers);
+  }
+
+  /**
+   * Send a message
+   * @param {Object} messageData - Message data
+   * @param {string} messageData.to - Recipient phone number
+   * @param {string} messageData.message - Message text
+   * @param {string} [messageData.fileUrl] - Optional file URL
+   * @param {string} [messageData.fileType] - File type
+   * @param {Object} [messageData.variables] - Template variables
+   * @param {string} [messageData.contentSid] - Template content SID
+   * @returns {Promise<Object>} Message result
+   */
+  async sendMessage(messageData) {
+    if (!this.isInitialized) {
+      throw new Error('Nexus not initialized. Call initialize() first.');
+    }
+    return await this.messaging.sendMessage(messageData);
+  }
+
+  /**
+   * Send a scheduled message
+   * @param {Object} scheduledMessage - Scheduled message data
+   * @param {string} scheduledMessage.to - Recipient phone number
+   * @param {string} scheduledMessage.message - Message text
+   * @param {Date|string} scheduledMessage.sendAt - When to send the message
+   * @returns {Promise<Object>} Scheduled message result
+   */
+  async sendScheduledMessage(scheduledMessage) {
+    if (!this.isInitialized) {
+      throw new Error('Nexus not initialized. Call initialize() first.');
+    }
+    return await this.messaging.sendScheduledMessage(scheduledMessage);
+  }
+
+  /**
+   * Process incoming message
+   * @param {Object} rawMessage - Raw message from webhook/event
+   * @returns {Promise<void>}
+   */
+  async processMessage(rawMessage) {
+    if (!this.isInitialized) {
+      throw new Error('Nexus not initialized. Call initialize() first.');
+    }
+
+    let messageData = rawMessage;
+    
+    // Parse message if parser is available
+    if (this.messageParser) {
+      messageData = this.messageParser.parseMessage(rawMessage);
+    }
+
+    return await this.messaging.processIncomingMessage(messageData);
+  }
+
+
+  /**
+   * Get connection status
+   * @returns {boolean} Connection status
+   */
+  isConnected() {
+    return this.messaging.isConnected();
+  }
+
+  /**
+   * Disconnect all services
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    await this.messaging.disconnect();
+    if (this.storage) {
+      await this.storage.disconnect();
+    }
+  }
+
+  // Expose individual components for advanced usage
+  /**
+   * Get messaging instance
+   * @returns {NexusMessaging} Messaging instance
+   */
+  getMessaging() {
+    return this.messaging;
+  }
+
+  /**
+   * Get storage instance
+   * @returns {MongoStorage|null} Storage instance
+   */
+  getStorage() {
+    return this.storage;
+  }
+
+  /**
+   * Get message parser instance
+   * @returns {MessageParser|null} Parser instance
+   */
+  getMessageParser() {
+    return this.messageParser;
+  }
+
+  /**
+   * Get LLM provider instance
+   * @returns {DefaultLLMProvider|null} LLM provider instance
+   */
+  getLLMProvider() {
+    return this.llmProvider;
+  }
+}
+
+// Export main class and individual components
+module.exports = {
+  Nexus,
+  NexusMessaging,
+  TwilioProvider,
+  BaileysProvider,
+  MongoStorage,
+  MessageParser,
+  adapters,
+  core,
+  storage,
+  utils,
+  models
+};

package/lib/models/index.js

@@ -0,0 +1,9 @@
+const { Message, getMessageValues, formatTimestamp } = require('./messageModel');
+const { Thread } = require('./threadModel');
+
+module.exports = {
+  Message,
+  Thread,
+  getMessageValues,
+  formatTimestamp
+};

package/lib/models/messageModel.js

@@ -0,0 +1,91 @@
+const mongoose = require('mongoose');
+const moment = require('moment-timezone');
+
+const messageSchema = new mongoose.Schema({
+  nombre_whatsapp: { type: String, required: true },
+  numero: { type: String, required: true },
+  body: { type: String, required: true },
+  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 },
+  group_id: { type: String, default: null },
+  reply_id: { type: String, default: null },
+  processed: { type: Boolean, default: false },
+  thread_id: { type: String, default: null },
+  assistant_id: { type: String, default: null },
+  content_sid: { type: String, default: null },
+  from_me: { type: Boolean, default: false },
+  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 },
+    fileName: { type: String, default: null },
+    fileSize: { type: Number, default: null },
+    duration: { type: Number, default: null },
+    caption: { type: String, default: null },
+    thumbnail: { type: String, default: null },
+    metadata: { type: Object, default: null }
+  },
+  memoryType: {
+    type: String,
+    enum: ['active', 'archived'],
+    default: 'active',
+    index: true
+  },
+  read: {
+    type: Boolean,
+    default: false
+  }
+}, { timestamps: true });
+
+messageSchema.index({ message_id: 1, body: 1 }, { unique: true });
+
+messageSchema.pre('save', function (next) {
+  if (this.timestamp) {
+    this.timestamp = moment.tz(this.timestamp, 'America/Mexico_City').toDate();
+  }
+  next();
+});
+
+const Message = mongoose.model('Message', messageSchema);
+
+function formatTimestamp(unixTimestamp) {
+  const date = new Date(unixTimestamp * 1000);
+  return date.toLocaleString('sv-MX', {
+    timeZone: 'America/Mexico_City',
+    hour12: false,
+  }).replace(' ', 'T').slice(0, 19);  
+}
+
+function getMessageValues(message, content, reply, is_media) {
+  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 from_me = message.key.fromMe;
+
+  return {
+    nombre_whatsapp,
+    numero,
+    body,
+    timestamp,
+    message_id,
+    is_group,
+    is_media,
+    group_id,
+    reply_id,
+    from_me
+  };
+}
+
+module.exports = {
+  Message,
+  getMessageValues,
+  formatTimestamp
+};

package/lib/models/threadModel.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const threadSchema = new mongoose.Schema({
+  code: { type: String, required: true },
+  assistant_id: { type: String, required: true },
+  thread_id: { type: String, required: true },
+  patient_id: { type: String, default: null },
+  run_id: { type: String, default: null },
+  nombre: { type: String, default: null },
+  active: { type: Boolean, default: true },
+  stopped: { type: Boolean, default: false },
+  nextSid: { type: [String], default: [] }
+}, { timestamps: true });
+
+threadSchema.index({ code: 1, active: 1 });
+threadSchema.index({ thread_id: 1 });
+
+const Thread = mongoose.model('Thread', threadSchema);
+
+module.exports = { Thread };