oblien 1.1.0 → 1.1.1

package/agents.js

@@ -0,0 +1,14 @@
+/**
+ * Agents Module Entry Point
+ * Import this for AI agents management only
+ */
+
+export { OblienAgents, Agent, AgentSettings, Tools } from './src/agents/index.js';
+
+export default { 
+    OblienAgents, 
+    Agent, 
+    AgentSettings, 
+    Tools 
+};
+

package/icons.js

@@ -0,0 +1,11 @@
+/**
+ * Icons Module Entry Point
+ * Import this for icons functionality only
+ */
+
+export { OblienIcons } from './src/icons/index.js';
+
+export default { 
+    OblienIcons 
+};
+

package/index.js

@@ -5,6 +5,10 @@
 
 import { OblienClient } from './src/client.js';
 import { OblienChat, ChatSession } from './src/chat/index.js';
+import { OblienAgents, Agent, Tools, AgentSettings } from './src/agents/index.js';
+import { OblienSandboxes, Sandbox } from './src/sandbox/index.js';
+import { OblienSearch } from './src/search/index.js';
+import { OblienIcons } from './src/icons/index.js';
 import { OblienNamespaces, Namespace } from './src/namespaces/index.js';
 import { OblienCredits } from './src/credits/index.js';
 import { 
@@ -17,6 +21,10 @@ import {
 // Re-export as named exports
 export { OblienClient };
 export { OblienChat, ChatSession };
+export { OblienAgents, Agent, Tools, AgentSettings };
+export { OblienSandboxes, Sandbox };
+export { OblienSearch };
+export { OblienIcons };
 export { OblienNamespaces, Namespace };
 export { OblienCredits };
 export { 
@@ -31,6 +39,14 @@ export default {
     OblienClient,
     OblienChat,
     ChatSession,
+    OblienAgents,
+    Agent,
+    Tools,
+    AgentSettings,
+    OblienSandboxes,
+    Sandbox,
+    OblienSearch,
+    OblienIcons,
     OblienNamespaces,
     Namespace,
     OblienCredits,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oblien",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Server-side SDK for Oblien AI Platform - Build AI-powered applications with chat, agents, and workflows",
   "main": "index.js",
   "type": "module",
@@ -9,7 +9,11 @@
     ".": "./index.js",
     "./chat": "./chat.js",
     "./namespaces": "./namespaces.js",
-    "./credits": "./credits.js"
+    "./credits": "./credits.js",
+    "./agents": "./agents.js",
+    "./sandbox": "./sandbox.js",
+    "./search": "./search.js",
+    "./icons": "./icons.js"
   },
   "scripts": {
     "test": "node --test tests/**/*.test.js"
@@ -61,6 +65,9 @@
     "namespaces.js",
     "credits.js",
     "agents.js",
+    "sandbox.js",
+    "search.js",
+    "icons.js",
     "workflows.js",
     "README.md",
     "LICENSE"

package/sandbox.js

@@ -0,0 +1,12 @@
+/**
+ * Sandbox Module Entry Point
+ * Import this for sandbox management only
+ */
+
+export { OblienSandboxes, Sandbox } from './src/sandbox/index.js';
+
+export default { 
+    OblienSandboxes, 
+    Sandbox 
+};
+

package/search.js

@@ -0,0 +1,11 @@
+/**
+ * Search Module Entry Point
+ * Import this for search functionality only
+ */
+
+export { OblienSearch } from './src/search/index.js';
+
+export default { 
+    OblienSearch 
+};
+

package/src/agents/agent.js

@@ -0,0 +1,229 @@
+/**
+ * Agent Class
+ * Represents a single agent with methods for operations
+ */
+
+import { AgentSettings } from './settings.js';
+
+export class Agent {
+    /**
+     * @param {Object} options
+     * @param {import('../client.js').OblienClient} options.client - Oblien client instance
+     * @param {string} [options.agentId] - Agent ID
+     */
+    constructor({ client, agentId = null }) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+        this.agentId = agentId;
+        this._settings = null;
+    }
+
+    /**
+     * Get settings manager for this agent
+     * @returns {AgentSettings} Settings manager instance
+     */
+    get settings() {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required for settings operations');
+        }
+        
+        if (!this._settings) {
+            this._settings = new AgentSettings({
+                client: this.client,
+                agentId: this.agentId
+            });
+        }
+
+        return this._settings;
+    }
+
+    /**
+     * 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 { name, prompts, description, namespace, collectionIds, settings } = options;
+
+        if (!name) {
+            throw new Error('Agent name is required');
+        }
+        if (!prompts) {
+            throw new Error('Agent prompts are required');
+        }
+
+        const response = await this.client.post('ai/agents/create', {
+            name,
+            prompts,
+            description,
+            namespace,
+            collectionIds,
+            settings
+        });
+
+        if (response.agentId || response.id) {
+            this.agentId = response.agentId || response.id;
+        }
+
+        return response;
+    }
+
+    /**
+     * Get agent details
+     * @param {string} [section] - Optional section to retrieve
+     * @returns {Promise<Object>} Agent data
+     */
+    async get(section = null) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        const path = section 
+            ? `ai/agents/${this.agentId}/${section}`
+            : `ai/agents/${this.agentId}`;
+
+        return await this.client.get(path);
+    }
+
+    /**
+     * Update agent
+     * @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(updates) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        return await this.client.put(`ai/agents/${this.agentId}`, updates);
+    }
+
+    /**
+     * Delete agent
+     * @param {Object} [options] - Delete options
+     * @param {string} [options.namespace] - Namespace for validation
+     * @returns {Promise<Object>} Delete result
+     */
+    async delete(options = {}) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        // Use POST with body for DELETE with namespace validation
+        const response = await fetch(this.client._buildURL(`ai/agents/${this.agentId}`), {
+            method: 'DELETE',
+            headers: this.client.getAuthHeaders(),
+            body: JSON.stringify(options)
+        });
+
+        return this.client._handleResponse(response);
+    }
+
+    /**
+     * Get agent overview/analytics
+     * @param {Object} [options] - Query options
+     * @param {number} [options.days=7] - Number of days for activity data
+     * @returns {Promise<Object>} Analytics data
+     */
+    async getOverview(options = {}) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        return await this.client.get(`ai/agents/${this.agentId}/overview`, options);
+    }
+
+    /**
+     * Get agent sessions
+     * @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(options = {}) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        return await this.client.get(`ai/agents/${this.agentId}/sessions`, options);
+    }
+
+    /**
+     * Get agent bans
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Bans data
+     */
+    async getBans(options = {}) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        return await this.client.get(`ai/agents/${this.agentId}/bans`, options);
+    }
+
+
+    /**
+     * Get agent users
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Agent users data
+     */
+    async getUsers(options = {}) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+
+        return await this.client.get(`ai/agents/${this.agentId}/users`, options);
+    }
+
+    /**
+     * Get specific agent user
+     * @param {string} userId - User ID
+     * @returns {Promise<Object>} User data
+     */
+    async getUser(userId) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+        if (!userId) {
+            throw new Error('User ID is required');
+        }
+
+        return await this.client.get(`ai/agents/${this.agentId}/users/${userId}`);
+    }
+
+    /**
+     * Reset user limits
+     * @param {string} userId - User ID
+     * @returns {Promise<Object>} Reset result
+     */
+    async resetUserLimits(userId) {
+        if (!this.agentId) {
+            throw new Error('Agent ID is required');
+        }
+        if (!userId) {
+            throw new Error('User ID is required');
+        }
+
+        return await this.client.post(`ai/agents/${this.agentId}/users/${userId}/reset-limits`);
+    }
+}
+
+export default Agent;
+

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;
+