@toothfairyai/cli 1.2.0 → 1.5.0

package/src/api.js

@@ -367,6 +367,8 @@ class ToothFairyAPI {
    * @param {Function} onEvent - Callback function called for each event
    * @param {Object} attachments - File attachments (images, audios, videos, files)
    * @param {boolean} showProgress - Show all progress events from SSE endpoint (default: false)
+   * @param {string|null} chatId - Existing chat ID to continue conversation (default: null, creates new chat)
+   * @param {boolean} rawStream - Enable raw streaming mode for chunk-by-chunk output (default: false)
    * @returns {Promise<void>} - Promise resolves when streaming is complete
    *
    * Event Types Explained:
@@ -399,7 +401,8 @@ class ToothFairyAPI {
     onEvent,
     attachments = {},
     showProgress = false,
-    chatId = null
+    chatId = null,
+    rawStream = false
   ) {
     try {
       // Use defaults for optional parameters
@@ -463,6 +466,7 @@ class ToothFairyAPI {
           chatid: chatId,
           messages: [messageData],
           agentid: agentId,
+          raw_stream: rawStream,
         };
 
         // Stream the agent response using the dedicated streaming URL
@@ -511,7 +515,14 @@ class ToothFairyAPI {
                       }
 
                       // Standard event processing (always executed for backward compatibility)
-                      if (eventData.status) {
+                      // Handle raw_stream token events (streaming text chunks)
+                      if (eventData.type === 'token' && eventData.chunk !== undefined) {
+                        // Token streaming event - emit as 'data' with text field for compatibility
+                        onEvent('data', {
+                          ...eventData,
+                          text: eventData.chunk,
+                        });
+                      } else if (eventData.status) {
                         if (eventData.status === 'connected') {
                           onEvent('status', eventData);
                         } else if (eventData.status === 'complete') {
@@ -520,10 +531,15 @@ class ToothFairyAPI {
                           // 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 };
+                            // metadata can be an object or a JSON string
+                            if (typeof eventData.metadata === 'object') {
+                              metadata = eventData.metadata;
+                            } else {
+                              try {
+                                metadata = JSON.parse(eventData.metadata);
+                              } catch (e) {
+                                metadata = { raw_metadata: eventData.metadata };
+                              }
                             }
                           }
 
@@ -550,8 +566,17 @@ class ToothFairyAPI {
                         eventData.text &&
                         eventData.type === 'message'
                       ) {
-                        // This is streaming text data
+                        // This is streaming text data (non-raw_stream mode)
                         onEvent('data', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.chat_created === true
+                      ) {
+                        // Chat creation event from raw_stream mode
+                        onEvent('chat_created', {
+                          ...eventData,
+                          chatId: eventData.chatid,
+                        });
                       } else if (
                         eventData.type === 'message' &&
                         eventData.images !== undefined
@@ -568,7 +593,7 @@ class ToothFairyAPI {
                         eventData.type === 'chat_created' ||
                         eventData.event === 'chat_created'
                       ) {
-                        // Chat creation event
+                        // Chat creation event (legacy format)
                         onEvent('chat_created', eventData);
                       } else {
                         // Generic event data
@@ -660,6 +685,7 @@ class ToothFairyAPI {
           customerId: customerId,
           providerId: providerId,
           customerInfo: customerInfo,
+          raw_stream: rawStream,
         };
 
         // Stream the agent response using the dedicated streaming URL
@@ -708,7 +734,14 @@ class ToothFairyAPI {
                       }
 
                       // Standard event processing (always executed for backward compatibility)
-                      if (eventData.status) {
+                      // Handle raw_stream token events (streaming text chunks)
+                      if (eventData.type === 'token' && eventData.chunk !== undefined) {
+                        // Token streaming event - emit as 'data' with text field for compatibility
+                        onEvent('data', {
+                          ...eventData,
+                          text: eventData.chunk,
+                        });
+                      } else if (eventData.status) {
                         if (eventData.status === 'connected') {
                           onEvent('status', eventData);
                         } else if (eventData.status === 'complete') {
@@ -717,10 +750,15 @@ class ToothFairyAPI {
                           // 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 };
+                            // metadata can be an object or a JSON string
+                            if (typeof eventData.metadata === 'object') {
+                              metadata = eventData.metadata;
+                            } else {
+                              try {
+                                metadata = JSON.parse(eventData.metadata);
+                              } catch (e) {
+                                metadata = { raw_metadata: eventData.metadata };
+                              }
                             }
                           }
 
@@ -747,8 +785,17 @@ class ToothFairyAPI {
                         eventData.text &&
                         eventData.type === 'message'
                       ) {
-                        // This is streaming text data
+                        // This is streaming text data (non-raw_stream mode)
                         onEvent('data', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.chat_created === true
+                      ) {
+                        // Chat creation event from raw_stream mode
+                        onEvent('chat_created', {
+                          ...eventData,
+                          chatId: eventData.chatid,
+                        });
                       } else if (
                         eventData.type === 'message' &&
                         eventData.images !== undefined
@@ -765,7 +812,7 @@ class ToothFairyAPI {
                         eventData.type === 'chat_created' ||
                         eventData.event === 'chat_created'
                       ) {
-                        // Chat creation event
+                        // Chat creation event (legacy format)
                         onEvent('chat_created', eventData);
                       } else {
                         // Generic event data
@@ -2058,6 +2105,569 @@ class ToothFairyAPI {
       throw error;
     }
   }
+
+  // Agent Management Methods
+
+  /**
+   * Create a new agent
+   *
+   * @param {Object} agentData - Agent configuration
+   * @param {string} agentData.label - Agent display name (required)
+   * @param {string} agentData.mode - Agent mode: retriever, coder, chatter, planner, computer, voice (required)
+   * @param {string} agentData.interpolationString - System prompt template (required)
+   * @param {string} agentData.goals - Primary objectives (required)
+   * @param {number} agentData.temperature - Response creativity level (required)
+   * @param {number} agentData.maxTokens - Maximum tokens in response (required)
+   * @param {number} agentData.maxHistory - Maximum conversation history (required)
+   * @param {number} agentData.topK - Number of top results for retrieval (required)
+   * @param {number} agentData.docTopK - Number of top documents to retrieve (required)
+   * @returns {Promise<Object>} Created agent data
+   */
+  async createAgent(agentData) {
+    try {
+      return await this._makeRequest('POST', 'agent/create', agentData);
+    } catch (error) {
+      console.error(`Error creating agent: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a specific agent by ID
+   *
+   * @param {string} agentId - Agent ID to retrieve
+   * @returns {Promise<Object>} Agent data
+   */
+  async getAgent(agentId) {
+    try {
+      return await this._makeRequest('GET', `agent/get/${agentId}`);
+    } catch (error) {
+      console.error(`Error getting agent: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all agents in the workspace
+   *
+   * @param {number} limit - Maximum number of agents to return (optional)
+   * @param {number} offset - Number of agents to skip (optional)
+   * @returns {Promise<Object>} List of agents
+   */
+  async listAgents(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'agent/list', params);
+    } catch (error) {
+      console.error(`Error listing agents: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing agent
+   *
+   * @param {string} agentId - Agent ID to update
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated agent data
+   */
+  async updateAgent(agentId, fields) {
+    try {
+      const updateData = {
+        id: agentId,
+        ...fields,
+      };
+      return await this._makeRequest('POST', `agent/update/${agentId}`, updateData);
+    } catch (error) {
+      console.error(`Error updating agent: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete an agent
+   *
+   * @param {string} agentId - Agent ID to delete
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteAgent(agentId) {
+    try {
+      return await this._makeRequest('DELETE', `agent/delete/${agentId}`);
+    } catch (error) {
+      console.error(`Error deleting agent: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Authorization Management Methods
+
+  /**
+   * Create a new authorization
+   *
+   * @param {Object} authData - Authorization configuration
+   * @returns {Promise<Object>} Created authorization data
+   */
+  async createAuthorization(authData) {
+    try {
+      return await this._makeRequest('POST', 'authorisation/create', authData);
+    } catch (error) {
+      console.error(`Error creating authorization: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a specific authorization by ID
+   *
+   * @param {string} authId - Authorization ID to retrieve
+   * @returns {Promise<Object>} Authorization data
+   */
+  async getAuthorization(authId) {
+    try {
+      return await this._makeRequest('GET', `authorisation/get/${authId}`);
+    } catch (error) {
+      console.error(`Error getting authorization: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all authorizations in the workspace
+   *
+   * @param {number} limit - Maximum number of authorizations to return (optional)
+   * @param {number} offset - Number of authorizations to skip (optional)
+   * @returns {Promise<Object>} List of authorizations
+   */
+  async listAuthorizations(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'authorisation/list', params);
+    } catch (error) {
+      console.error(`Error listing authorizations: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing authorization
+   *
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated authorization data
+   */
+  async updateAuthorization(fields) {
+    try {
+      return await this._makeRequest('POST', 'authorisation/update', fields);
+    } catch (error) {
+      console.error(`Error updating authorization: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete an authorization
+   *
+   * @param {string} authId - Authorization ID to delete
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteAuthorization(authId) {
+    try {
+      return await this._makeRequest('DELETE', `authorisation/delete/${authId}`);
+    } catch (error) {
+      console.error(`Error deleting authorization: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Benchmark Management Methods
+
+  /**
+   * Create a new benchmark
+   *
+   * @param {Object} benchmarkData - Benchmark configuration
+   * @returns {Promise<Object>} Created benchmark data
+   */
+  async createBenchmark(benchmarkData) {
+    try {
+      return await this._makeRequest('POST', 'benchmark/create', benchmarkData);
+    } catch (error) {
+      console.error(`Error creating benchmark: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a specific benchmark by ID
+   *
+   * @param {string} benchmarkId - Benchmark ID to retrieve
+   * @returns {Promise<Object>} Benchmark data
+   */
+  async getBenchmark(benchmarkId) {
+    try {
+      return await this._makeRequest('GET', `benchmark/get/${benchmarkId}`);
+    } catch (error) {
+      console.error(`Error getting benchmark: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all benchmarks in the workspace
+   *
+   * @param {number} limit - Maximum number of benchmarks to return (optional)
+   * @param {number} offset - Number of benchmarks to skip (optional)
+   * @returns {Promise<Object>} List of benchmarks
+   */
+  async listBenchmarks(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'benchmark/list', params);
+    } catch (error) {
+      console.error(`Error listing benchmarks: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing benchmark
+   *
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated benchmark data
+   */
+  async updateBenchmark(fields) {
+    try {
+      return await this._makeRequest('POST', 'benchmark/update', fields);
+    } catch (error) {
+      console.error(`Error updating benchmark: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a benchmark
+   *
+   * @param {string} benchmarkId - Benchmark ID to delete
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteBenchmark(benchmarkId) {
+    try {
+      return await this._makeRequest('DELETE', `benchmark/delete/${benchmarkId}`);
+    } catch (error) {
+      console.error(`Error deleting benchmark: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Billing Methods
+
+  /**
+   * Get monthly usage and cost information
+   *
+   * @param {number} month - Month number (1-12)
+   * @param {number} year - Year (4-digit)
+   * @returns {Promise<Object>} Monthly cost data
+   */
+  async getMonthCosts(month, year) {
+    try {
+      const params = {
+        workspaceId: this.workspaceId,
+        month: month,
+        year: year,
+      };
+      return await this._makeRequest('GET', 'billing/monthCosts', params);
+    } catch (error) {
+      console.error(`Error getting month costs: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Channel Management Methods
+
+  /**
+   * Create a new communication channel
+   *
+   * @param {Object} channelData - Channel configuration
+   * @returns {Promise<Object>} Created channel data
+   */
+  async createChannel(channelData) {
+    try {
+      return await this._makeRequest('POST', 'channel/create', channelData);
+    } catch (error) {
+      console.error(`Error creating channel: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a specific channel by ID
+   *
+   * @param {string} channelId - Channel ID to retrieve
+   * @returns {Promise<Object>} Channel data
+   */
+  async getChannel(channelId) {
+    try {
+      return await this._makeRequest('GET', `channel/get/${channelId}`);
+    } catch (error) {
+      console.error(`Error getting channel: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all channels in the workspace
+   *
+   * @param {number} limit - Maximum number of channels to return (optional)
+   * @param {number} offset - Number of channels to skip (optional)
+   * @returns {Promise<Object>} List of channels
+   */
+  async listChannels(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'channel/list', params);
+    } catch (error) {
+      console.error(`Error listing channels: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing channel
+   *
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated channel data
+   */
+  async updateChannel(fields) {
+    try {
+      return await this._makeRequest('POST', 'channel/update', fields);
+    } catch (error) {
+      console.error(`Error updating channel: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a channel
+   *
+   * @param {string} channelId - Channel ID to delete
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteChannel(channelId) {
+    try {
+      return await this._makeRequest('DELETE', `channel/delete/${channelId}`);
+    } catch (error) {
+      console.error(`Error deleting channel: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Connection Management Methods
+
+  /**
+   * Get a specific connection by ID
+   *
+   * @param {string} connectionId - Connection ID to retrieve
+   * @returns {Promise<Object>} Connection data
+   */
+  async getConnection(connectionId) {
+    try {
+      return await this._makeRequest('GET', `connection/get/${connectionId}`);
+    } catch (error) {
+      console.error(`Error getting connection: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all connections in the workspace
+   *
+   * @param {number} limit - Maximum number of connections to return (optional)
+   * @param {number} offset - Number of connections to skip (optional)
+   * @returns {Promise<Object>} List of connections
+   */
+  async listConnections(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'connection/list', params);
+    } catch (error) {
+      console.error(`Error listing connections: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a connection
+   *
+   * @param {string} connectionId - Connection ID to delete
+   * @returns {Promise<Object>} Deletion result
+   */
+  async deleteConnection(connectionId) {
+    try {
+      return await this._makeRequest('DELETE', `connection/delete/${connectionId}`);
+    } catch (error) {
+      console.error(`Error deleting connection: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Dictionary Management Methods
+
+  /**
+   * Get a specific dictionary entry by ID
+   *
+   * @param {string} dictionaryId - Dictionary entry ID to retrieve
+   * @returns {Promise<Object>} Dictionary entry data
+   */
+  async getDictionary(dictionaryId) {
+    try {
+      return await this._makeRequest('GET', `dictionary/get/${dictionaryId}`);
+    } catch (error) {
+      console.error(`Error getting dictionary: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all dictionary entries in the workspace
+   *
+   * @param {number} limit - Maximum number of entries to return (optional)
+   * @param {number} offset - Number of entries to skip (optional)
+   * @returns {Promise<Object>} List of dictionary entries
+   */
+  async listDictionaries(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'dictionary/list', params);
+    } catch (error) {
+      console.error(`Error listing dictionaries: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Embedding Management Methods
+
+  /**
+   * Get a specific embedding by ID
+   *
+   * @param {string} embeddingId - Embedding ID to retrieve
+   * @returns {Promise<Object>} Embedding data
+   */
+  async getEmbedding(embeddingId) {
+    try {
+      return await this._makeRequest('GET', `embedding/get/${embeddingId}`);
+    } catch (error) {
+      console.error(`Error getting embedding: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Settings Management Methods
+
+  /**
+   * Get charting settings for the workspace
+   *
+   * @param {string} settingsId - Settings ID to retrieve
+   * @returns {Promise<Object>} Charting settings data
+   */
+  async getChartingSettings(settingsId) {
+    try {
+      return await this._makeRequest('GET', `charting_settings/get/${settingsId}`);
+    } catch (error) {
+      console.error(`Error getting charting settings: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update charting settings for the workspace
+   *
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated charting settings data
+   */
+  async updateChartingSettings(fields) {
+    try {
+      return await this._makeRequest('POST', 'charting_settings/update', fields);
+    } catch (error) {
+      console.error(`Error updating charting settings: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get embeddings settings for the workspace
+   *
+   * @param {string} settingsId - Settings ID to retrieve
+   * @returns {Promise<Object>} Embeddings settings data
+   */
+  async getEmbeddingsSettings(settingsId) {
+    try {
+      return await this._makeRequest('GET', `embeddings_settings/get/${settingsId}`);
+    } catch (error) {
+      console.error(`Error getting embeddings settings: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update embeddings settings for the workspace
+   *
+   * @param {Object} fields - Fields to update
+   * @returns {Promise<Object>} Updated embeddings settings data
+   */
+  async updateEmbeddingsSettings(fields) {
+    try {
+      return await this._makeRequest('POST', 'embeddings_settings/update', fields);
+    } catch (error) {
+      console.error(`Error updating embeddings settings: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Stream Management Methods
+
+  /**
+   * Get a specific stream by ID
+   *
+   * @param {string} streamId - Stream ID to retrieve
+   * @returns {Promise<Object>} Stream data
+   */
+  async getStream(streamId) {
+    try {
+      return await this._makeRequest('GET', `stream/get/${streamId}`);
+    } catch (error) {
+      console.error(`Error getting stream: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * List all streams in the workspace
+   *
+   * @param {number} limit - Maximum number of streams to return (optional)
+   * @param {number} offset - Number of streams to skip (optional)
+   * @returns {Promise<Object>} List of streams
+   */
+  async listStreams(limit = null, offset = null) {
+    try {
+      const params = { workspaceid: this.workspaceId };
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
+      return await this._makeRequest('GET', 'stream/list', params);
+    } catch (error) {
+      console.error(`Error listing streams: ${error.message}`);
+      throw error;
+    }
+  }
 }
 
 module.exports = ToothFairyAPI;