oblien 1.0.7 → 1.1.1

package/src/agents/index.js

@@ -0,0 +1,212 @@
+/**
+ * Agents Module
+ * Manages AI agents, their settings, and operations
+ */
+
+import { Agent } from './agent.js';
+import { Tools } from './tools.js';
+
+export class OblienAgents {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+        this._tools = null;
+    }
+
+    /**
+     * Get tools manager
+     * @returns {Tools} Tools manager instance
+     */
+    get tools() {
+        if (!this._tools) {
+            this._tools = new Tools(this.client);
+        }
+        return this._tools;
+    }
+
+    /**
+     * Create a new agent
+     * @param {Object} options - Agent options
+     * @param {string} options.name - Agent name (required)
+     * @param {Object} options.prompts - Agent prompts/configuration (required)
+     * @param {string} [options.description] - Agent description
+     * @param {string} [options.namespace] - Namespace for organization
+     * @param {Array<string>} [options.collectionIds] - Collection IDs
+     * @param {Object} [options.settings] - Agent settings
+     * @returns {Promise<Object>} Created agent data
+     */
+    async create(options) {
+        const agent = new Agent({ client: this.client });
+        return await agent.create(options);
+    }
+
+    /**
+     * Get agent by ID
+     * @param {string} agentId - Agent ID
+     * @param {string} [section] - Optional section to retrieve
+     * @returns {Promise<Object>} Agent data
+     */
+    async get(agentId, section = null) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.get(section);
+    }
+
+    /**
+     * List all agents with filtering and pagination
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Max results (default: 50, max: 100)
+     * @param {number} [options.offset] - Offset for pagination
+     * @param {string} [options.namespace] - Filter by namespace
+     * @returns {Promise<Object>} Agents data with pagination info
+     */
+    async list(options = {}) {
+        const response = await this.client.get('ai/agents/list', options);
+        return response;
+    }
+
+    /**
+     * Search agents
+     * @param {string} query - Search query
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Max results (default: 20)
+     * @param {string} [options.namespace] - Filter by namespace
+     * @returns {Promise<Object>} Search results
+     */
+    async search(query, options = {}) {
+        const response = await this.client.get('ai/agents/search', {
+            q: query,
+            ...options
+        });
+        return response;
+    }
+
+    /**
+     * Update agent
+     * @param {string} agentId - Agent ID
+     * @param {Object} updates - Fields to update
+     * @param {string} [updates.name] - Agent name
+     * @param {string} [updates.description] - Description
+     * @param {Object} [updates.prompts] - Prompts
+     * @param {Object} [updates.settings] - Settings
+     * @param {string} [updates.namespace] - Namespace (for validation)
+     * @returns {Promise<Object>} Update result
+     */
+    async update(agentId, updates) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.update(updates);
+    }
+
+    /**
+     * Delete agent
+     * @param {string} agentId - Agent ID
+     * @param {Object} [options] - Delete options
+     * @param {string} [options.namespace] - Namespace for validation
+     * @returns {Promise<Object>} Delete result
+     */
+    async delete(agentId, options = {}) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.delete(options);
+    }
+
+    /**
+     * Get agent overview/analytics
+     * @param {string} agentId - Agent ID
+     * @param {Object} [options] - Query options
+     * @param {number} [options.days=7] - Number of days for activity data
+     * @returns {Promise<Object>} Analytics data
+     */
+    async getOverview(agentId, options = {}) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.getOverview(options);
+    }
+
+    /**
+     * Get agent sessions
+     * @param {string} agentId - Agent ID
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Max results
+     * @param {number} [options.offset] - Offset for pagination
+     * @param {string} [options.search] - Search term
+     * @param {string} [options.sortBy] - Sort by field
+     * @param {string} [options.sortOrder] - Sort order (asc/desc)
+     * @returns {Promise<Object>} Sessions data
+     */
+    async getSessions(agentId, options = {}) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.getSessions(options);
+    }
+
+    /**
+     * Get agent bans
+     * @param {string} agentId - Agent ID
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Bans data
+     */
+    async getBans(agentId, options = {}) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.getBans(options);
+    }
+
+    /**
+     * Get platform stats
+     * @returns {Promise<Object>} Platform statistics
+     */
+    async getStats() {
+        return await this.client.get('ai/agents/stats');
+    }
+
+
+    /**
+     * Get agent users
+     * @param {string} agentId - Agent ID
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Agent users data
+     */
+    async getUsers(agentId, options = {}) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.getUsers(options);
+    }
+
+    /**
+     * Get specific agent user
+     * @param {string} agentId - Agent ID
+     * @param {string} userId - User ID
+     * @returns {Promise<Object>} User data
+     */
+    async getUser(agentId, userId) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.getUser(userId);
+    }
+
+    /**
+     * Reset user limits
+     * @param {string} agentId - Agent ID
+     * @param {string} userId - User ID
+     * @returns {Promise<Object>} Reset result
+     */
+    async resetUserLimits(agentId, userId) {
+        const agent = new Agent({ client: this.client, agentId });
+        return await agent.resetUserLimits(userId);
+    }
+
+    /**
+     * Create an Agent instance for chaining operations
+     * @param {string} [agentId] - Agent ID
+     * @returns {Agent} Agent instance
+     */
+    agent(agentId) {
+        return new Agent({ client: this.client, agentId });
+    }
+}
+
+export { Agent };
+export { Tools } from './tools.js';
+export { AgentSettings } from './settings.js';
+export default OblienAgents;
+

package/src/agents/settings.js

@@ -0,0 +1,100 @@
+/**
+ * Agent Settings Class
+ * Manages all agent settings with proper sections
+ */
+
+export class AgentSettings {
+    /**
+     * @param {Object} options
+     * @param {import('../client.js').OblienClient} options.client - Oblien client instance
+     * @param {string} options.agentId - Agent ID
+     */
+    constructor({ client, agentId }) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+        if (!agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        this.client = client;
+        this.agentId = agentId;
+    }
+
+    /**
+     * Update boolean switches
+     * @param {Object} switches - Switch values
+     * @param {boolean} [switches.enable_memory] - Enable conversation memory
+     * @param {boolean} [switches.allow_thinking] - Allow thinking process
+     * @param {boolean} [switches.allow_images] - Allow image uploads
+     * @param {boolean} [switches.allow_videos] - Allow video uploads
+     * @param {boolean} [switches.allow_audio] - Allow audio uploads
+     * @param {boolean} [switches.allow_documents] - Allow document uploads
+     * @param {boolean} [switches.allow_built_in] - Allow built-in tools
+     * @returns {Promise<Object>} Update result
+     */
+    async updateSwitches(switches) {
+        return await this.client.put(`ai/agents/${this.agentId}/switches`, switches);
+    }
+
+    /**
+     * Update model configuration
+     * @param {Object} config - Model configuration
+     * @param {string} [config.model] - Model name (e.g., 'oblien-master')
+     * @param {number} [config.temperature] - Temperature 0-2 (default: 1)
+     * @param {number} [config.max_tokens] - Max tokens 1-200000 (default: 2000)
+     * @param {number} [config.top_p] - Top P 0-1 (default: 1)
+     * @returns {Promise<Object>} Update result
+     */
+    async updateModelConfig(config) {
+        return await this.client.put(`ai/agents/${this.agentId}/model-config`, config);
+    }
+
+    /**
+     * Update tools array
+     * @param {Array<string>} tools - Array of tool slugs
+     * @returns {Promise<Object>} Update result
+     */
+    async updateTools(tools) {
+        return await this.client.put(`ai/agents/${this.agentId}/tools`, { tools });
+    }
+
+    /**
+     * Update guest limits
+     * @param {Object} limits - Guest limit configuration
+     * @param {boolean} [limits.enabled] - Enable guest limits
+     * @param {number} [limits.max_requests_per_minute] - Max requests per minute (1-1000)
+     * @param {number} [limits.max_messages_per_hour] - Max messages per hour (1-10000)
+     * @param {number} [limits.max_messages_per_day] - Max messages per day (1-50000)
+     * @param {number} [limits.max_total_tokens_per_day] - Max total tokens per day (1000-10000000)
+     * @param {number} [limits.max_input_tokens_per_day] - Max input tokens per day (1000-10000000)
+     * @param {number} [limits.max_output_tokens_per_day] - Max output tokens per day (1000-10000000)
+     * @returns {Promise<Object>} Update result
+     */
+    async updateGuestLimits(limits) {
+        return await this.client.put(`ai/agents/${this.agentId}/guest-limits`, limits);
+    }
+
+    /**
+     * Update context settings
+     * @param {Object} context - Context configuration
+     * @param {number} [context.max_history_messages] - Max history messages
+     * @param {number} [context.history_token_limit] - History token limit
+     * @returns {Promise<Object>} Update result
+     */
+    async updateContext(context) {
+        return await this.client.put(`ai/agents/${this.agentId}/context`, context);
+    }
+
+    /**
+     * Get all settings sections
+     * @returns {Promise<Object>} All settings
+     */
+    async getAll() {
+        const agent = await this.client.get(`ai/agents/${this.agentId}`);
+        return agent.agent?.settings || agent.settings || {};
+    }
+}
+
+export default AgentSettings;
+

package/src/agents/tools.js

@@ -0,0 +1,155 @@
+/**
+ * Tools Class
+ * Manages AI tools - listing, searching, creating, and getting tool details
+ */
+
+export class Tools {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+    }
+
+    /**
+     * List all available tools with optional filters
+     * @param {Object} [options] - Filter options
+     * @param {string} [options.type] - Filter by type: 'client' | 'server' | 'hybrid'
+     * @param {string} [options.category] - Filter by category: 'custom' | 'file' | 'search' | 'terminal' | 'browser' | 'project' | 'web'
+     * @param {boolean} [options.requireEnvironment] - Filter by environment requirement
+     * @param {boolean} [options.myCustomTools] - Show only user's custom tools
+     * @returns {Promise<Object>} List of tools
+     */
+    async list(options = {}) {
+        const params = {};
+
+        if (options.type) params.type = options.type;
+        if (options.category) params.category = options.category;
+        if (options.requireEnvironment !== undefined) {
+            params.require_environment = String(options.requireEnvironment);
+        }
+        if (options.myCustomTools) params.my_custom_tools = 'true';
+
+        const response = await this.client.get('ai/tools', params);
+        return response;
+    }
+
+    /**
+     * Search tools by query
+     * @param {string} query - Search query
+     * @param {Object} [options] - Filter options
+     * @param {string} [options.type] - Filter by type
+     * @param {string} [options.category] - Filter by category
+     * @param {boolean} [options.myCustomTools] - Show only user's custom tools
+     * @returns {Promise<Object>} Search results
+     */
+    async search(query, options = {}) {
+        const params = { q: query };
+
+        if (options.type) params.type = options.type;
+        if (options.category) params.category = options.category;
+        if (options.myCustomTools) params.my_custom_tools = 'true';
+
+        const response = await this.client.get('ai/tools/search', params);
+        return response;
+    }
+
+    /**
+     * Get tool by slug
+     * @param {string} slug - Tool slug/ID
+     * @returns {Promise<Object>} Tool details
+     */
+    async get(slug) {
+        if (!slug) {
+            throw new Error('Tool slug is required');
+        }
+
+        const response = await this.client.get(`ai/tools/${slug}`);
+        return response;
+    }
+
+    /**
+     * Create a custom tool (client-side tool)
+     * @param {Object} toolData - Tool configuration
+     * @param {string} toolData.slug - Unique tool slug/ID
+     * @param {string} toolData.tool_name - Tool name
+     * @param {string} toolData.tool_description - Tool description
+     * @param {string} [toolData.icon] - Tool icon
+     * @param {string} [toolData.type='client'] - Tool type: 'client' | 'server' | 'hybrid'
+     * @param {string} [toolData.category='custom'] - Tool category
+     * @param {Object} [toolData.input_scheme] - Input schema/parameters
+     * @param {Object} [toolData.output_scheme] - Output schema
+     * @param {string} [toolData.prompt] - Tool prompt/instructions
+     * @param {boolean} [toolData.require_environment=false] - Requires context/environment
+     * @param {string} [toolData.context_type] - Context type if required
+     * @returns {Promise<Object>} Created tool
+     */
+    async create(toolData) {
+        const {
+            slug,
+            tool_name,
+            tool_description,
+            icon,
+            type = 'client',
+            category = 'custom',
+            input_scheme,
+            output_scheme,
+            prompt,
+            require_environment = false,
+            context_type
+        } = toolData;
+
+        if (!slug || !tool_name || !tool_description) {
+            throw new Error('slug, tool_name, and tool_description are required');
+        }
+
+        const payload = {
+            slug,
+            tool_name,
+            tool_description,
+            icon,
+            type,
+            category,
+            input_scheme,
+            output_scheme,
+            prompt,
+            require_environment,
+            context_type
+        };
+
+        const response = await this.client.post('ai/tools', payload);
+        return response;
+    }
+
+    /**
+     * Validate tool IDs
+     * @param {Array<string>} toolIds - Array of tool slugs to validate
+     * @returns {Promise<Object>} Validation result
+     */
+    async validate(toolIds) {
+        if (!Array.isArray(toolIds)) {
+            throw new Error('toolIds must be an array');
+        }
+
+        // Get all tools and check which ones exist
+        const allTools = await this.list();
+        const existingSlugs = allTools.tools.map(t => t.slug);
+        
+        const validIds = toolIds.filter(id => existingSlugs.includes(id));
+        const invalidIds = toolIds.filter(id => !existingSlugs.includes(id));
+
+        return {
+            valid: invalidIds.length === 0,
+            validIds,
+            invalidIds,
+            error: invalidIds.length > 0 ? `Invalid tool IDs: ${invalidIds.join(', ')}` : null
+        };
+    }
+}
+
+export default Tools;
+

package/src/client.js

@@ -107,6 +107,24 @@ export class OblienClient {
         return this._handleResponse(response);
     }
 
+    /**
+     * Make PATCH request
+     * @param {string} path - API path
+     * @param {Object} [body] - Request body
+     * @returns {Promise<any>} Response data
+     */
+    async patch(path, body = {}) {
+        const headers = this.getAuthHeaders();
+        
+        const response = await fetch(this._buildURL(path), {
+            method: 'PATCH',
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        return this._handleResponse(response);
+    }
+
     /**
      * Make DELETE request
      * @param {string} path - API path