oblien 1.1.0 → 1.1.2

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/chat/index.js

@@ -34,6 +34,12 @@ export class OblienChat {
      * @param {string} options.agentId - Agent ID to chat with
      * @param {string} [options.workflowId] - Workflow ID (if using workflow)
      * @param {Object} [options.workspace] - Workspace configuration
+     * @param {string} [options.endUserId] - End user ID (for client's end users)
+     * @param {string} [options.namespace] - Guest namespace for rate limiting
+     * @param {boolean} [options.isGuest] - Is this a guest session
+     * @param {string} [options.ipAddress] - IP address of the user
+     * @param {string} [options.userAgent] - User agent of the user
+     * @param {string} [options.fingerprint] - Fingerprint of the user
      * @returns {Promise<Object>} Session data with token
      */
     async createSession(options) {
@@ -54,10 +60,11 @@ export class OblienChat {
      * @param {string} [options.workflowId] - Workflow ID
      * @param {Object} [options.metadata] - Additional guest metadata
      * @param {Object} [options.workspace] - Workspace configuration
+     * @param {string} [options.endUserId] - End user ID (for client's end users)
      * @returns {Promise<Object>} Session data with token and guest info
      */
     async createGuestSession(options) {
-        const { ip, fingerprint, agentId, workflowId, metadata = {}, workspace } = options;
+        const { ip, fingerprint, agentId, workflowId, metadata = {}, workspace, endUserId } = options;
 
         if (!ip) {
             throw new Error('IP address is required for guest sessions');
@@ -81,6 +88,7 @@ export class OblienChat {
             ipAddress: ip,
             userAgent: metadata.userAgent,
             fingerprint: fingerprint,
+            endUserId: endUserId,
         });
 
         const sessionData = await session.create();

package/src/chat/session.js

@@ -16,6 +16,7 @@ export class ChatSession {
      * @param {string} [options.ipAddress] - IP address of the user
      * @param {string} [options.userAgent] - User agent of the user
      * @param {string} [options.fingerprint] - Fingerprint of the user
+     * @param {string} [options.endUserId] - End user ID (for client's end users)
      */
     constructor(options) {
         if (!options.client) {
@@ -38,6 +39,7 @@ export class ChatSession {
         this.ipAddress = options.ipAddress || null;
         this.userAgent = options.userAgent || null;
         this.fingerprint = options.fingerprint || null;
+        this.endUserId = options.endUserId || null;
     }
 
     /**
@@ -54,6 +56,7 @@ export class ChatSession {
             ip_address: this.ipAddress,
             user_agent: this.userAgent,
             fingerprint: this.fingerprint,
+            end_user_id: this.endUserId,
         };
 
         this.data = await this.client.post('ai/session/create', payload);

package/src/client.js

@@ -6,21 +6,19 @@
 export class OblienClient {
     /**
      * @param {Object} config - Configuration options
-     * @param {string} config.apiKey - Your Oblien Client ID (x-client-id)
-     * @param {string} config.apiSecret - Your Oblien Client Secret (x-client-secret)
-     * @param {string} [config.baseURL] - Base URL for API (default: https://api.oblien.com)
-     * @param {string} [config.version] - API version (default: v1)
+     * @param {string} config.clientId - Your Oblien Client ID (x-client-id)
+     * @param {string} config.clientSecret - Your Oblien Client Secret (x-client-secret)
      */
     constructor(config) {
-        if (!config || !config.apiKey) {
-            throw new Error('Oblien API key (client ID) is required');
+        if (!config || !config.clientId) {
+            throw new Error('Oblien client ID is required');
         }
-        if (!config.apiSecret) {
-            throw new Error('Oblien API secret (client secret) is required');
+        if (!config.clientSecret) {
+            throw new Error('Oblien client secret is required');
         }
 
-        this.clientId = config.apiKey;
-        this.clientSecret = config.apiSecret;
+        this.clientId = config.clientId;
+        this.clientSecret = config.clientSecret;
         this.baseURL = config.baseURL || 'https://api.oblien.com';
     }
 

package/src/icons/index.js

@@ -0,0 +1,185 @@
+/**
+ * Oblien Icons Module
+ * Search and fetch icons, images, and videos
+ */
+
+export class OblienIcons {
+    constructor(client) {
+        if (!client) throw new Error('Oblien client is required');
+        this.client = client;
+    }
+
+    /**
+     * Search for icons using semantic search
+     * 
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {number} options.offset - Pagination offset (default: 0)
+     * @param {number} options.limit - Number of results (default: 100)
+     * @returns {Promise<Object>} Search results with pagination info
+     * 
+     * @example
+     * const results = await icons.search('home', { limit: 50 });
+     * // Returns:
+     * // {
+     * //   results: [
+     * //     {
+     * //       url: 'https://cdn.oblien.com/static/png-icons/...',
+     * //       filename: 'home-outline.png',
+     * //       name: 'home',
+     * //       description: 'home',
+     * //       style: 'Outline',
+     * //       score: 0.95,
+     * //       success: true
+     * //     }
+     * //   ],
+     * //   hasMore: true,
+     * //   offset: 50,
+     * //   total: 245
+     * // }
+     */
+    async search(query, options = {}) {
+        if (!query || typeof query !== 'string') {
+            throw new Error('Query must be a non-empty string');
+        }
+
+        const { offset = 0, limit = 100 } = options;
+
+        return this.client.post('icons/search-icons', {
+            query: query.trim(),
+            offset,
+            limit
+        });
+    }
+
+    /**
+     * Fetch multiple items (icons, images, videos) with semantic matching
+     * 
+     * @param {Array<Object>} items - Array of items to fetch
+     * @param {string} items[].type - Type: 'icon', 'image', or 'video'
+     * @param {string} items[].description - Description for semantic matching
+     * @param {boolean} items[].is_vector - Whether the item is a vector (optional)
+     * @param {string} items[].variant - Variant type (optional, for images/videos)
+     * @returns {Promise<Array>} Array of fetched items with URLs
+     * 
+     * @example
+     * const items = await icons.fetch([
+     *   { type: 'icon', description: 'user profile' },
+     *   { type: 'icon', description: 'settings gear' },
+     *   { type: 'image', description: 'mountain landscape' },
+     *   { type: 'video', description: 'ocean waves' }
+     * ]);
+     * 
+     * // Returns:
+     * // [
+     * //   {
+     * //     url: 'https://cdn.oblien.com/static/icons/...',
+     * //     description: 'user profile',
+     * //     style: 'Outline',
+     * //     success: true
+     * //   },
+     * //   {
+     * //     url: 'https://cdn.oblien.com/static/assets/...',
+     * //     type: 'image',
+     * //     description: 'mountain landscape',
+     * //     variant: 'regular',
+     * //     success: true
+     * //   }
+     * // ]
+     */
+    async fetch(items) {
+        if (!Array.isArray(items) || items.length === 0) {
+            throw new Error('Items must be a non-empty array');
+        }
+
+        // Validate items
+        for (const item of items) {
+            if (!item.type || !['icon', 'image', 'video'].includes(item.type)) {
+                throw new Error('Each item must have a valid type: icon, image, or video');
+            }
+            if (!item.description || typeof item.description !== 'string') {
+                throw new Error('Each item must have a description string');
+            }
+        }
+
+        return this.client.post('icons/fetch', { data: items });
+    }
+
+    /**
+     * Fetch a single icon
+     * Convenience method for fetching one icon
+     * 
+     * @param {string} description - Icon description
+     * @returns {Promise<Object>} Icon object with URL
+     * 
+     * @example
+     * const icon = await icons.fetchIcon('home');
+     * // Returns: { url: '...', description: 'home', style: 'Outline', success: true }
+     */
+    async fetchIcon(description) {
+        if (!description || typeof description !== 'string') {
+            throw new Error('Description must be a non-empty string');
+        }
+
+        const result = await this.fetch([{ type: 'icon', description }]);
+        return result[0] || null;
+    }
+
+    /**
+     * Fetch multiple icons at once
+     * Convenience method for fetching multiple icons
+     * 
+     * @param {Array<string>} descriptions - Array of icon descriptions
+     * @returns {Promise<Array>} Array of icon objects
+     * 
+     * @example
+     * const icons = await icons.fetchIcons(['home', 'settings', 'user']);
+     * // Returns: [{ url: '...', description: 'home', ... }, ...]
+     */
+    async fetchIcons(descriptions) {
+        if (!Array.isArray(descriptions) || descriptions.length === 0) {
+            throw new Error('Descriptions must be a non-empty array');
+        }
+
+        const items = descriptions.map(desc => ({ type: 'icon', description: desc }));
+        return this.fetch(items);
+    }
+
+    /**
+     * Search icons with pagination helper
+     * Automatically handles pagination and returns all results
+     * 
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {number} options.maxResults - Maximum results to fetch (default: 500)
+     * @param {number} options.batchSize - Results per batch (default: 100)
+     * @returns {Promise<Array>} All matching icons
+     * 
+     * @example
+     * const allIcons = await icons.searchAll('home', { maxResults: 200 });
+     * // Returns: [{ url: '...', name: 'home', ... }, ...]
+     */
+    async searchAll(query, options = {}) {
+        const { maxResults = 500, batchSize = 100 } = options;
+        const allResults = [];
+        let offset = 0;
+        let hasMore = true;
+
+        while (hasMore && allResults.length < maxResults) {
+            const response = await this.search(query, {
+                offset,
+                limit: Math.min(batchSize, maxResults - allResults.length)
+            });
+
+            if (response.results && response.results.length > 0) {
+                allResults.push(...response.results);
+            }
+
+            hasMore = response.hasMore && allResults.length < maxResults;
+            offset = response.offset;
+        }
+
+        return allResults;
+    }
+}
+