@toothfairyai/cli 1.0.3 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toothfairyai/cli",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "Command-line interface for ToothFairy AI API",
   "main": "index.js",
   "bin": {
@@ -43,7 +43,8 @@
     "dotenv": "^16.0.3",
     "js-yaml": "^4.1.0",
     "ora": "^5.4.1",
-    "table": "^6.8.1"
+    "table": "^6.8.1",
+    "eventsource": "^2.0.2"
   },
   "devDependencies": {
     "eslint": "^8.32.0",

package/src/api.js

@@ -1,14 +1,15 @@
-const axios = require("axios");
+const axios = require('axios');
 
 class ToothFairyAPI {
-  constructor(baseUrl, aiUrl, apiKey, workspaceId, verbose = false) {
+  constructor(baseUrl, aiUrl, aiStreamUrl, apiKey, workspaceId, verbose = false) {
     this.baseUrl = baseUrl;
     this.aiUrl = aiUrl;
+    this.aiStreamUrl = aiStreamUrl;
     this.workspaceId = workspaceId;
     this.verbose = verbose;
     this.headers = {
-      "Content-Type": "application/json",
-      "x-api-key": apiKey,
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
     };
   }
 
@@ -19,46 +20,46 @@ class ToothFairyAPI {
       headers: this.headers,
     };
 
-    if (method === "POST" || method === "PUT") {
+    if (method === 'POST' || method === 'PUT') {
       if (data) {
         data = { workspaceid: this.workspaceId, ...data };
       }
       config.data = data;
-    } else if (method === "GET" && data) {
+    } else if (method === 'GET' && data) {
       // For GET requests with data, add as query parameters
       const params = new URLSearchParams(data);
       config.url += `?${params.toString()}`;
     }
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- API Request Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- API Request Debug ---'));
       console.error(chalk.dim(`Method: ${method}`));
       console.error(chalk.dim(`URL: ${config.url}`));
       console.error(chalk.dim(`Headers: ${JSON.stringify(config.headers, null, 2)}`));
       if (config.data) {
         console.error(chalk.dim(`Data: ${JSON.stringify(config.data, null, 2)}`));
       }
-      console.error(chalk.dim("----------------------\n"));
+      console.error(chalk.dim('----------------------\n'));
     }
 
     try {
       const response = await axios(config);
       
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- API Response Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- API Response Debug ---'));
         console.error(chalk.dim(`Status: ${response.status} ${response.statusText}`));
         console.error(chalk.dim(`Response Headers: ${JSON.stringify(response.headers, null, 2)}`));
         console.error(chalk.dim(`Response Data: ${JSON.stringify(response.data, null, 2)}`));
-        console.error(chalk.dim("------------------------\n"));
+        console.error(chalk.dim('------------------------\n'));
       }
       
       return response.data;
     } catch (error) {
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.red("\n--- API Error Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.red('\n--- API Error Debug ---'));
         console.error(chalk.red(`Error: ${error.message}`));
         if (error.response) {
           console.error(chalk.red(`Status: ${error.response.status} ${error.response.statusText}`));
@@ -68,13 +69,13 @@ class ToothFairyAPI {
         if (error.request) {
           console.error(chalk.red(`Request Config: ${JSON.stringify(error.config, null, 2)}`));
         }
-        console.error(chalk.red("---------------------\n"));
+        console.error(chalk.red('---------------------\n'));
       }
       
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "API request failed"
+            error.response.data.message || 'API request failed'
           }`
         );
       }
@@ -83,34 +84,34 @@ class ToothFairyAPI {
   }
 
   async createChat(chatData) {
-    return this._makeRequest("POST", "chat/create", chatData);
+    return this._makeRequest('POST', 'chat/create', chatData);
   }
 
   async updateChat(chatData) {
-    return this._makeRequest("POST", "chat/update", chatData);
+    return this._makeRequest('POST', 'chat/update', chatData);
   }
 
   async getChat(chatId) {
-    return this._makeRequest("GET", `chat/get/${chatId}`);
+    return this._makeRequest('GET', `chat/get/${chatId}`);
   }
 
   async createMessage(messageData) {
-    return this._makeRequest("POST", "chat_message/create", messageData);
+    return this._makeRequest('POST', 'chat_message/create', messageData);
   }
 
   async getMessage(messageId) {
-    return this._makeRequest("GET", `chat_message/get/${messageId}`);
+    return this._makeRequest('GET', `chat_message/get/${messageId}`);
   }
 
   async getAllChats() {
-    return this._makeRequest("GET", "chat/list", {
+    return this._makeRequest('GET', 'chat/list', {
       workspaceid: this.workspaceId,
     });
   }
 
   async getAgentResponse(agentData) {
     const config = {
-      method: "POST",
+      method: 'POST',
       url: `${this.aiUrl}/chatter`,
       headers: this.headers,
       data: { workspaceid: this.workspaceId, ...agentData },
@@ -123,7 +124,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Agent request failed"
+            error.response.data.message || 'Agent request failed'
           }`
         );
       }
@@ -145,14 +146,14 @@ class ToothFairyAPI {
         customerId ||
         `cli-user-${
           Math.abs(
-            message.split("").reduce((a, b) => {
+            message.split('').reduce((a, b) => {
               a = (a << 5) - a + b.charCodeAt(0);
               return a & a;
             }, 0)
           ) % 10000
         }`;
-      phoneNumber = phoneNumber || "+1234567890";
-      providerId = providerId || "default-sms-provider";
+      phoneNumber = phoneNumber || '+1234567890';
+      providerId = providerId || 'default-sms-provider';
 
       const chatData = {
         name: customerId,
@@ -176,8 +177,8 @@ class ToothFairyAPI {
       const messageData = {
         chatID: createdChat.id,
         text: message,
-        role: "user",
-        userID: "CLI",
+        role: 'user',
+        userID: 'CLI',
       };
       const createdMessage = await this.createMessage(messageData);
       // console.log(`Message created: ${createdMessage.id}`);;
@@ -188,7 +189,7 @@ class ToothFairyAPI {
           {
             text: createdMessage.text,
             role: createdMessage.role,
-            userID: createdMessage.userID || "System User",
+            userID: createdMessage.userID || 'System User',
           },
         ],
         agentid: agentId,
@@ -209,7 +210,7 @@ class ToothFairyAPI {
 
   async searchDocuments(text, topK = 10, metadata = null) {
     if (topK < 1 || topK > 50) {
-      throw new Error("topK must be between 1 and 50");
+      throw new Error('topK must be between 1 and 50');
     }
 
     const searchData = {
@@ -222,7 +223,7 @@ class ToothFairyAPI {
     }
 
     const config = {
-      method: "POST",
+      method: 'POST',
       url: `${this.aiUrl}/searcher`,
       headers: this.headers,
       data: { workspaceid: this.workspaceId, ...searchData },
@@ -235,13 +236,247 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Search request failed"
+            error.response.data.message || 'Search request failed'
           }`
         );
       }
       throw error;
     }
   }
+
+  /**
+   * Send a message to an agent and get a streaming response.
+   * 
+   * This method handles the complete workflow with Server-Sent Events (SSE):
+   * 1. Creates a chat
+   * 2. Creates a message  
+   * 3. Streams the agent response in real-time
+   * 
+   * @param {string} message - The message to send to the agent
+   * @param {string} agentId - The ID of the agent to send the message to
+   * @param {string|null} phoneNumber - Phone number for SMS channel
+   * @param {string|null} customerId - Customer identifier
+   * @param {string|null} providerId - SMS provider ID
+   * @param {Object} customerInfo - Additional customer information
+   * @param {Function} onEvent - Callback function called for each event
+   * @returns {Promise<void>} - Promise resolves when streaming is complete
+   * 
+   * Event Types Explained:
+   * - 'status': Connection status updates ('connected', 'complete')
+   * - 'progress': Agent processing status updates:
+   *   * 'init': Agent initialization started
+   *   * 'initial_setup_completed': Basic setup finished
+   *   * 'tools_processing_completed': Tools processing finished
+   *   * 'replying': Agent is generating response (text streaming starts)
+   *   * 'updating_memory': Agent is updating conversation memory
+   *   * 'memory_updated': Memory update completed
+   * - 'data': Actual response text chunks (progressive text building)
+   * - 'complete': Final response with all metadata
+   * - 'error': Error occurred during streaming
+   * 
+   * The onEvent callback receives: (eventType, eventData) => {}
+   */
+  async sendMessageToAgentStream(
+    message,
+    agentId,
+    phoneNumber = null,
+    customerId = null,
+    providerId = null,
+    customerInfo = {},
+    onEvent
+  ) {
+    try {
+      // Use defaults for optional parameters
+      customerId =
+        customerId ||
+        `cli-user-${
+          Math.abs(
+            message.split('').reduce((a, b) => {
+              a = (a << 5) - a + b.charCodeAt(0);
+              return a & a;
+            }, 0)
+          ) % 10000
+        }`;
+      phoneNumber = phoneNumber || '+1234567890';
+      providerId = providerId || 'default-sms-provider';
+
+      // Create chat first
+      const chatData = {
+        name: customerId,
+        primaryRole: agentId,
+        externalParticipantId: phoneNumber,
+        channelSettings: {
+          sms: {
+            isEnabled: true,
+            recipient: phoneNumber,
+            providerID: providerId,
+          },
+        },
+        customerId: customerId,
+        customerInfo: customerInfo,
+        isAIReplying: true,
+      };
+
+      const createdChat = await this.createChat(chatData);
+      console.debug(`Chat created: ${createdChat.id}`);
+
+      // Create message
+      const messageData = {
+        chatID: createdChat.id,
+        text: message,
+        role: 'user',
+        userID: 'CLI',
+      };
+      const createdMessage = await this.createMessage(messageData);
+      console.debug(`Message created: ${createdMessage.id}`);
+
+      // Prepare agent data for streaming
+      const agentData = {
+        workspaceid: this.workspaceId,
+        messages: [
+          {
+            text: createdMessage.text,
+            role: createdMessage.role,
+            userID: createdMessage.userID || 'System User',
+          },
+        ],
+        agentid: agentId,
+      };
+
+      // Stream the agent response using the dedicated streaming URL
+      const streamUrl = `${this.aiStreamUrl}/agent`; // Using streaming URL for /agent endpoint
+
+
+      return new Promise((resolve, reject) => {
+        // For POST requests with EventSource, we need to use a different approach
+        // EventSource doesn't support POST requests directly, so we'll use axios with streaming
+        const config = {
+          method: 'POST',
+          url: streamUrl,
+          headers: {
+            ...this.headers,
+            'Accept': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+          },
+          data: agentData,
+          responseType: 'stream',
+          timeout: 300000, // 5 minute timeout
+        };
+
+        axios(config)
+          .then(response => {
+            let buffer = '';
+            
+            response.data.on('data', (chunk) => {
+              buffer += chunk.toString();
+              
+              // Process complete lines
+              const lines = buffer.split('\n');
+              buffer = lines.pop() || ''; // Keep the incomplete line in buffer
+              
+              for (const line of lines) {
+                if (line.trim() === '') continue;
+                
+                if (line.startsWith('data: ')) {
+                  const dataStr = line.slice(6); // Remove 'data: ' prefix
+                  
+                  try {
+                    const eventData = JSON.parse(dataStr);
+                    
+                    // Determine event type based on the data structure
+                    if (eventData.status) {
+                      if (eventData.status === 'connected') {
+                        onEvent('status', eventData);
+                      } else if (eventData.status === 'complete') {
+                        onEvent('status', eventData);
+                      } else if (eventData.status === 'inProgress') {
+                        // Parse metadata to understand what's happening
+                        let metadata = {};
+                        if (eventData.metadata) {
+                          try {
+                            metadata = JSON.parse(eventData.metadata);
+                          } catch (e) {
+                            metadata = { raw_metadata: eventData.metadata };
+                          }
+                        }
+                        
+                        // Determine progress type
+                        if (metadata.agent_processing_status) {
+                          const processingStatus = metadata.agent_processing_status;
+                          onEvent('progress', {
+                            ...eventData,
+                            processing_status: processingStatus,
+                            metadata_parsed: metadata
+                          });
+                        } else {
+                          onEvent('progress', { ...eventData, metadata_parsed: metadata });
+                        }
+                        
+                      } else if (eventData.status === 'fulfilled') {
+                        // Final response with complete data
+                        onEvent('complete', eventData);
+                      }
+                      
+                    } else if (eventData.text && eventData.type === 'message') {
+                      // This is streaming text data
+                      onEvent('data', eventData);
+                      
+                    } else if (eventData.type === 'message' && eventData.images !== undefined) {
+                      // Additional message metadata (images, files, etc.)
+                      onEvent('metadata', eventData);
+                      
+                    } else if (eventData.type === 'message' && eventData.callbackMetadata) {
+                      // Callback metadata with function details and execution plan
+                      onEvent('callback', eventData);
+                      
+                    } else {
+                      // Generic event data
+                      onEvent('unknown', eventData);
+                    }
+                    
+                  } catch (e) {
+                    console.error(`Failed to parse SSE data: ${dataStr}, error: ${e.message}`);
+                    onEvent('error', {
+                      error: 'json_decode_error',
+                      raw_data: dataStr,
+                      message: e.message
+                    });
+                  }
+                }
+              }
+            });
+            
+            response.data.on('end', () => {
+              resolve();
+            });
+            
+            response.data.on('error', (error) => {
+              onEvent('error', {
+                error: 'stream_error',
+                message: error.message
+              });
+              reject(error);
+            });
+            
+          })
+          .catch(error => {
+            onEvent('error', {
+              error: 'request_error',
+              message: error.message
+            });
+            reject(error);
+          });
+      });
+      
+    } catch (error) {
+      console.error(`Error in sendMessageToAgentStream: ${error.message}`);
+      onEvent('error', {
+        error: 'setup_error',
+        message: error.message
+      });
+      throw error;
+    }
+  }
 }
 
 module.exports = ToothFairyAPI;

package/src/config.js

@@ -4,9 +4,10 @@ const os = require('os');
 const yaml = require('js-yaml');
 
 class ToothFairyConfig {
-    constructor(baseUrl, aiUrl, apiKey, workspaceId) {
+    constructor(baseUrl, aiUrl, aiStreamUrl, apiKey, workspaceId) {
         this.baseUrl = baseUrl;
         this.aiUrl = aiUrl;
+        this.aiStreamUrl = aiStreamUrl;
         this.apiKey = apiKey;
         this.workspaceId = workspaceId;
     }
@@ -15,6 +16,7 @@ class ToothFairyConfig {
         return new ToothFairyConfig(
             process.env.TF_BASE_URL || 'https://api.toothfairyai.com',
             process.env.TF_AI_URL || 'https://ai.toothfairyai.com',
+            process.env.TF_AI_STREAM_URL || 'https://ais.toothfairyai.com',
             process.env.TF_API_KEY || '',
             process.env.TF_WORKSPACE_ID || ''
         );
@@ -37,6 +39,7 @@ class ToothFairyConfig {
         return new ToothFairyConfig(
             data.base_url || 'https://api.toothfairyai.com',
             data.ai_url || 'https://ai.toothfairyai.com',
+            data.ai_stream_url || 'https://ais.toothfairyai.com',
             data.api_key || '',
             data.workspace_id || ''
         );
@@ -50,6 +53,7 @@ class ToothFairyConfig {
         return {
             base_url: this.baseUrl,
             ai_url: this.aiUrl,
+            ai_stream_url: this.aiStreamUrl,
             api_key: this.apiKey,
             workspace_id: this.workspaceId
         };