@toothfairyai/cli 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toothfairyai/cli",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Command-line interface for ToothFairyAI API",
   "main": "index.js",
   "bin": {

package/src/api.js

@@ -2105,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;