oblien 1.0.7 → 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/credits.js

@@ -0,0 +1,11 @@
+/**
+ * Credits Module Entry Point
+ * Import this for credits management only
+ */
+
+export { OblienCredits } from './src/credits/index.js';
+
+export default { 
+    OblienCredits
+};
+

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.d.ts

@@ -19,6 +19,7 @@ export class OblienClient {
     get(path: string, params?: Record<string, any>): Promise<any>;
     post(path: string, body?: Record<string, any>): Promise<any>;
     put(path: string, body?: Record<string, any>): Promise<any>;
+    patch(path: string, body?: Record<string, any>): Promise<any>;
     delete(path: string): Promise<any>;
 }
 
@@ -167,12 +168,272 @@ export class OblienChat {
     cleanupGuests(): Promise<number>;
 }
 
+// ============ Namespaces ============
+
+export interface NamespaceData {
+    id: string;
+    client_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    end_user_id?: string;
+    fingerprint?: string;
+    ip_address?: string;
+    user_agent?: string;
+    country?: string;
+    status: 'active' | 'inactive' | 'suspended' | 'archived';
+    type: string;
+    is_default: boolean;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    created_at: string;
+    updated_at: string;
+    last_active_at?: string;
+    archived_at?: string;
+}
+
+export interface CreateNamespaceOptions {
+    name: string;
+    slug?: string;
+    description?: string;
+    type?: 'default' | 'production' | 'testing' | 'development';
+    isDefault?: boolean;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    endUserId?: string;
+}
+
+export interface UpdateNamespaceOptions {
+    name?: string;
+    description?: string;
+    status?: 'active' | 'inactive' | 'suspended' | 'archived';
+    type?: string;
+    metadata?: Record<string, any>;
+    tags?: string[];
+}
+
+export interface ListNamespacesOptions {
+    limit?: number;
+    offset?: number;
+    status?: 'active' | 'inactive' | 'suspended' | 'archived';
+    type?: string;
+    search?: string;
+    sortBy?: 'name' | 'created_at' | 'updated_at' | 'last_active_at';
+    sortOrder?: 'ASC' | 'DESC';
+}
+
+export interface ServiceConfig {
+    id: number;
+    namespace_id: string;
+    service: string;
+    enabled: boolean;
+    config?: Record<string, any>;
+    rate_limit_requests?: number;
+    rate_limit_period?: string;
+    features?: string[];
+    created_at: string;
+    updated_at: string;
+}
+
+export interface ConfigureServiceOptions {
+    service: string;
+    enabled?: boolean;
+    config?: Record<string, any>;
+    rateLimitRequests?: number;
+    rateLimitPeriod?: 'minute' | 'hour' | 'day';
+    features?: string[];
+}
+
+export interface NamespaceUsage {
+    usage: Array<{
+        service: string;
+        date: string;
+        requests: number;
+        credits: number;
+        deductions: number;
+    }>;
+    summary: Array<{
+        service: string;
+        total_requests: number;
+        total_credits: number;
+        first_used: string;
+        last_used: string;
+    }>;
+    quotas: Array<any>;
+    active_sessions: number;
+}
+
+export class Namespace {
+    constructor(options: { client: OblienClient; namespaceId?: string; data?: NamespaceData });
+    
+    namespaceId: string | null;
+    data: NamespaceData | null;
+    
+    create(options: CreateNamespaceOptions): Promise<NamespaceData>;
+    get(identifier?: string): Promise<NamespaceData>;
+    update(updates: UpdateNamespaceOptions, namespaceId?: string): Promise<NamespaceData>;
+    delete(namespaceId?: string): Promise<any>;
+    getActivity(options?: { limit?: number; offset?: number }, namespaceId?: string): Promise<any[]>;
+    getUsage(options?: { service?: string; days?: number }, namespaceId?: string): Promise<NamespaceUsage>;
+    configureService(options: ConfigureServiceOptions, namespaceId?: string): Promise<ServiceConfig>;
+    listServices(namespaceId?: string): Promise<ServiceConfig[]>;
+    getServiceConfig(service: string, namespaceId?: string): Promise<ServiceConfig>;
+    toggleService(service: string, enabled: boolean, namespaceId?: string): Promise<ServiceConfig>;
+    deleteService(service: string, namespaceId?: string): Promise<any>;
+    bulkConfigureServices(services: ConfigureServiceOptions[], namespaceId?: string): Promise<ServiceConfig[]>;
+}
+
+export class OblienNamespaces {
+    constructor(client: OblienClient);
+    
+    create(options: CreateNamespaceOptions): Promise<NamespaceData>;
+    get(identifier: string): Promise<NamespaceData>;
+    list(options?: ListNamespacesOptions): Promise<{ success: boolean; data: NamespaceData[]; pagination: any }>;
+    update(namespaceId: string, updates: UpdateNamespaceOptions): Promise<NamespaceData>;
+    delete(namespaceId: string): Promise<any>;
+    getActivity(namespaceId: string, options?: { limit?: number; offset?: number }): Promise<any[]>;
+    getUsage(namespaceId: string, options?: { service?: string; days?: number }): Promise<NamespaceUsage>;
+    getAvailableServices(): Promise<any[]>;
+    configureService(namespaceId: string, options: ConfigureServiceOptions): Promise<ServiceConfig>;
+    listServices(namespaceId: string): Promise<ServiceConfig[]>;
+    getServiceConfig(namespaceId: string, service: string): Promise<ServiceConfig>;
+    toggleService(namespaceId: string, service: string, enabled: boolean): Promise<ServiceConfig>;
+    enableService(namespaceId: string, service: string): Promise<ServiceConfig>;
+    disableService(namespaceId: string, service: string): Promise<ServiceConfig>;
+    deleteService(namespaceId: string, service: string): Promise<any>;
+    bulkConfigureServices(namespaceId: string, services: ConfigureServiceOptions[]): Promise<ServiceConfig[]>;
+    namespace(namespaceId?: string): Namespace;
+}
+
+// ============ Credits ============
+
+export interface QuotaData {
+    id: number;
+    client_id: string;
+    namespace: string;
+    service: string;
+    quota_limit: number | null;
+    quota_used: number;
+    period: string;
+    period_start?: string;
+    period_end?: string;
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface CreditTransaction {
+    id: number;
+    client_id: string;
+    namespace: string;
+    end_user_id?: string;
+    amount: number;
+    client_balance_after: number;
+    namespace_quota_used?: number;
+    type: 'deduction' | 'addition' | 'refund' | 'adjustment';
+    service?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+    created_at: string;
+}
+
+export interface SetQuotaOptions {
+    namespace: string;
+    service: string;
+    quotaLimit: number;
+    period?: 'daily' | 'monthly' | 'unlimited';
+}
+
+export interface HistoryOptions {
+    namespace?: string;
+    endUserId?: string;
+    service?: string;
+    type?: 'deduction' | 'addition' | 'refund' | 'adjustment';
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+    offset?: number;
+    after?: string;
+    afterId?: number;
+}
+
+export interface SummaryOptions {
+    namespace?: string;
+    days?: number;
+    limit?: number;
+    offset?: number;
+    after?: number;
+}
+
+export interface CreditPackage {
+    id: string;
+    name: string;
+    credits: number;
+    price: number;
+    currency: string;
+    active: boolean;
+}
+
+export interface CalculateCostOptions {
+    packageId?: string;
+    amount?: number;
+    credits?: number;
+}
+
+export interface PurchaseOptions {
+    packageId?: string;
+    amount?: number;
+    metadata?: Record<string, any>;
+}
+
+export interface PurchaseHistoryOptions {
+    limit?: number;
+    offset?: number;
+    light?: boolean;
+}
+
+export class OblienCredits {
+    constructor(client: OblienClient);
+    
+    // Balance Management
+    getBalance(): Promise<number>;
+    addCredits(amount: number, reason?: string, metadata?: Record<string, any>): Promise<any>;
+    
+    // Quota Management
+    getNamespaceQuotas(options?: { limit?: number; offset?: number; after?: string; search?: string; status?: string }): Promise<any>;
+    getNamespaceDetails(namespace: string, options?: { days?: number }): Promise<any>;
+    setQuota(options: SetQuotaOptions): Promise<QuotaData>;
+    resetQuota(namespace: string, service: string): Promise<any>;
+    
+    // Usage History & Transactions
+    getHistory(options?: HistoryOptions): Promise<{ success: boolean; data: CreditTransaction[]; pagination: any }>;
+    getHistoryFilters(): Promise<{ namespaces: string[]; services: string[] }>;
+    getSummary(options?: SummaryOptions): Promise<any>;
+    getUsageStats(options?: { days?: number }): Promise<any>;
+    
+    // Pricing & Packages
+    getPackages(): Promise<CreditPackage[]>;
+    getPricingInfo(): Promise<any>;
+    calculateCost(options: CalculateCostOptions): Promise<any>;
+    calculateCredits(amount: number): Promise<any>;
+    
+    // Purchase Management
+    createCheckout(options: PurchaseOptions): Promise<any>;
+    getPurchaseHistory(options?: PurchaseHistoryOptions): Promise<any>;
+    getPurchaseDetails(purchaseId: string): Promise<any>;
+    getPurchaseSession(purchaseId: string): Promise<any>;
+    cancelPurchase(purchaseId: string): Promise<any>;
+}
+
 // ============ Exports ============
 
 declare const _default: {
     OblienClient: typeof OblienClient;
     OblienChat: typeof OblienChat;
     ChatSession: typeof ChatSession;
+    OblienNamespaces: typeof OblienNamespaces;
+    Namespace: typeof Namespace;
+    OblienCredits: typeof OblienCredits;
     GuestManager: typeof GuestManager;
     NodeCacheStorage: typeof NodeCacheStorage;
     InMemoryStorage: typeof InMemoryStorage;

package/index.js

@@ -5,6 +5,12 @@
 
 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 { 
     GuestManager, 
     NodeCacheStorage,
@@ -15,6 +21,12 @@ 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 { 
     GuestManager, 
     NodeCacheStorage,
@@ -27,6 +39,17 @@ export default {
     OblienClient,
     OblienChat,
     ChatSession,
+    OblienAgents,
+    Agent,
+    Tools,
+    AgentSettings,
+    OblienSandboxes,
+    Sandbox,
+    OblienSearch,
+    OblienIcons,
+    OblienNamespaces,
+    Namespace,
+    OblienCredits,
     GuestManager,
     NodeCacheStorage,
     InMemoryStorage,

package/namespaces.js

@@ -0,0 +1,12 @@
+/**
+ * Namespaces Module Entry Point
+ * Import this for namespace management only
+ */
+
+export { OblienNamespaces, Namespace } from './src/namespaces/index.js';
+
+export default { 
+    OblienNamespaces, 
+    Namespace
+};
+

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "oblien",
-  "version": "1.0.7",
+  "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",
   "types": "index.d.ts",
   "exports": {
     ".": "./index.js",
-    "./chat": "./chat.js"
+    "./chat": "./chat.js",
+    "./namespaces": "./namespaces.js",
+    "./credits": "./credits.js",
+    "./agents": "./agents.js",
+    "./sandbox": "./sandbox.js",
+    "./search": "./search.js",
+    "./icons": "./icons.js"
   },
   "scripts": {
     "test": "node --test tests/**/*.test.js"
@@ -56,7 +62,12 @@
     "index.js",
     "index.d.ts",
     "chat.js",
+    "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;
+