@peopl-health/nexus 1.1.7 → 1.1.8

package/lib/adapters/TwilioProvider.js

@@ -113,6 +113,25 @@ class TwilioProvider extends MessageProvider {
     const targetTime = new Date(sendTime);
     return Math.max(0, targetTime.getTime() - now.getTime());
   }
+
+  /**
+   * List templates from Twilio Content API
+   * @param {Object} options - Query options
+   * @returns {Promise<Array>} Array of templates
+   */
+  async listTemplates(options = {}) {
+    if (!this.isConnected || !this.twilioClient) {
+      throw new Error('Twilio provider not initialized');
+    }
+
+    try {
+      const { limit = 50 } = options;
+      const templates = await this.twilioClient.content.v1.contents.list({ limit });
+      return templates;
+    } catch (error) {
+      throw new Error(`Failed to list templates: ${error.message}`);
+    }
+  }
 }
 
 module.exports = { TwilioProvider };

package/lib/config/llmConfig.js

@@ -1,4 +1,3 @@
-// Temporary stub for llmConfig - should be replaced with Nexus LLM provider
 module.exports = {
-  openaiClient: null // This will be replaced with Nexus LLM provider
+  openaiClient: null
 };

package/lib/index.js

@@ -2,15 +2,8 @@ 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');
+const { MessageParser } = require('./utils/messageParser');
+const { DefaultLLMProvider } = require('./utils/defaultLLMProvider');
 
 /**
  * Main Nexus class that orchestrates all components

package/lib/services/twilioService.js

@@ -0,0 +1,56 @@
+// TwilioService that connects to Nexus Twilio provider
+let nexusProvider = null;
+
+// Configure the Nexus provider
+const configureNexusProvider = (provider) => {
+  nexusProvider = provider;
+};
+
+// Check if provider is configured and supports Twilio operations
+const checkTwilioSupport = () => {
+  if (!nexusProvider) {
+    throw new Error('Nexus provider not configured. Call configureNexusProvider() first.');
+  }
+  
+  if (!nexusProvider.listTemplates || typeof nexusProvider.listTemplates !== 'function') {
+    throw new Error('Twilio operations are only supported with Twilio provider');
+  }
+};
+
+// TwilioService wrapper that delegates to Nexus provider
+const TwilioService = {
+  async listTemplates(options = {}) {
+    checkTwilioSupport();
+    return await nexusProvider.listTemplates(options);
+  },
+
+  async getTemplate(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.getTemplate(sid);
+  },
+
+  async checkApprovalStatus(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.checkApprovalStatus(sid);
+  },
+
+  async submitForApproval(contentSid, name, category) {
+    checkTwilioSupport();
+    return await nexusProvider.submitForApproval(contentSid, name, category);
+  },
+
+  async deleteTemplate(sid) {
+    checkTwilioSupport();
+    return await nexusProvider.deleteTemplate(sid);
+  },
+
+  async createTemplate(templateData) {
+    checkTwilioSupport();
+    return await nexusProvider.createTemplate(templateData);
+  },
+
+  // Add any other Twilio operations as needed
+  configureNexusProvider
+};
+
+module.exports = TwilioService;

package/lib/utils/dateUtils.js

@@ -0,0 +1,26 @@
+const moment = require('moment-timezone');
+
+const ISO_DATE = 'YYYY-MM-DD';
+
+const parseStartTime = (startTime) => {
+  return moment(startTime);
+};
+
+const addDays = (date, days) => {
+  return moment(date).add(days, 'days');
+};
+
+const dateAndTimeFromStart = (startTime) => {
+  const momentTime = moment(startTime);
+  return {
+    date: momentTime.format(ISO_DATE),
+    time: momentTime.format('HH:mm')
+  };
+};
+
+module.exports = {
+  ISO_DATE,
+  parseStartTime,
+  addDays,
+  dateAndTimeFromStart
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "publishConfig": {
     "access": "public"

package/lib/utils/AssistantManager.js

@@ -1,218 +0,0 @@
-/**
- * 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 };