oblien 1.0.0

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "oblien",
+  "version": "1.0.0",
+  "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",
+    "./agents": "./agents.js",
+    "./workflows": "./workflows.js",
+    "./guest": "./src/utils/guest-manager.js"
+  },
+  "scripts": {
+    "test": "node --test tests/**/*.test.js"
+  },
+  "keywords": [
+    "oblien",
+    "ai",
+    "chat",
+    "agents",
+    "workflows",
+    "sdk",
+    "api",
+    "server-side",
+    "llm",
+    "assistant"
+  ],
+  "author": "Oblien",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:oblien/oblien-core.git"
+  },
+  "homepage": "https://oblien.com/docs/core-sdk",
+  "bugs": {
+    "url": "https://github.com/oblien/oblien-core/issues"
+  },
+  "dependencies": {
+    "node-cache": "^5.1.2"
+  },
+  "peerDependencies": {
+    "redis": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "redis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/",
+    "index.js",
+    "index.d.ts",
+    "chat.js",
+    "agents.js",
+    "workflows.js",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/chat/index.js

@@ -0,0 +1,149 @@
+/**
+ * Chat Module (Server-Side Session Management)
+ * Creates sessions and returns tokens for client-side chat
+ */
+
+import { ChatSession } from './session.js';
+import { GuestManager } from '../utils/guest-manager.js';
+
+export class OblienChat {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     * @param {Object} [options] - Configuration options
+     * @param {Object} [options.guestManager] - Custom guest manager instance
+     * @param {Object} [options.guestStorage] - Storage adapter for guest manager
+     * @param {number} [options.guestTTL] - Guest session TTL in seconds
+     */
+    constructor(client, options = {}) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+        
+        // Initialize guest manager if not provided
+        this.guestManager = options.guestManager || new GuestManager({
+            storage: options.guestStorage,
+            ttl: options.guestTTL,
+        });
+    }
+
+    /**
+     * Create a new session and return token for client
+     * @param {Object} options - Session options
+     * @param {string} options.agentId - Agent ID to chat with
+     * @param {string} [options.workflowId] - Workflow ID (if using workflow)
+     * @param {Object} [options.workspace] - Workspace configuration
+     * @returns {Promise<Object>} Session data with token
+     */
+    async createSession(options) {
+        const session = new ChatSession({
+            client: this.client,
+            ...options,
+        });
+
+        return await session.create();
+    }
+
+    /**
+     * Create a guest session based on IP
+     * @param {Object} options - Guest session options
+     * @param {string} options.ip - Client IP address
+     * @param {string} options.agentId - Agent ID to chat with
+     * @param {string} [options.workflowId] - Workflow ID
+     * @param {Object} [options.metadata] - Additional guest metadata
+     * @param {Object} [options.workspace] - Workspace configuration
+     * @returns {Promise<Object>} Session data with token and guest info
+     */
+    async createGuestSession(options) {
+        const { ip, agentId, workflowId, metadata, workspace } = options;
+
+        if (!ip) {
+            throw new Error('IP address is required for guest sessions');
+        }
+
+        // Get or create guest user
+        const guest = await this.guestManager.getOrCreateGuest(ip, metadata);
+
+        // Create session
+        const session = new ChatSession({
+            client: this.client,
+            agentId,
+            workflowId,
+            workspace,
+            isGuest: true,
+            namespace: guest.namespace,
+        });
+
+        const sessionData = await session.create();
+
+        // Link session to guest
+        await this.guestManager.addSession(guest.id, sessionData.sessionId);
+
+        return {
+            ...sessionData,
+            guest: {
+                id: guest.id,
+                namespace: guest.namespace,
+                createdAt: guest.createdAt,
+            },
+        };
+    }
+
+    /**
+     * Get guest by IP
+     * @param {string} ip - IP address
+     * @returns {Promise<Object|null>} Guest object or null
+     */
+    async getGuestByIP(ip) {
+        const guestId = this.guestManager.generateGuestId(ip);
+        return await this.guestManager.getGuest(guestId);
+    }
+
+    /**
+     * Get session info
+     * @param {string} sessionId - Session ID
+     * @returns {Promise<Object>} Session details
+     */
+    async getSession(sessionId) {
+        return await this.client.get(`ai/session/${sessionId}`);
+    }
+
+    /**
+     * List sessions
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Array of sessions
+     */
+    async listSessions(options = {}) {
+        const data = await this.client.get('ai/session', options);
+        return data.sessions || data;
+    }
+
+    /**
+     * Delete a session
+     * @param {string} sessionId - Session ID to delete
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteSession(sessionId) {
+        return await this.client.delete(`ai/session/${sessionId}`);
+    }
+
+    /**
+     * Get all active guests (admin/monitoring)
+     * @returns {Promise<Array>} Array of guest objects
+     */
+    async getAllGuests() {
+        return await this.guestManager.getAllGuests();
+    }
+
+    /**
+     * Clean up expired guests
+     * @returns {Promise<number>} Number of cleaned guests
+     */
+    async cleanupGuests() {
+        return await this.guestManager.cleanup();
+    }
+}
+
+export { ChatSession } from './session.js';
+export default OblienChat;

package/src/chat/session.js

@@ -0,0 +1,99 @@
+/**
+ * Chat Session Manager (Server-Side Only)
+ * Creates and manages chat sessions - returns tokens for client-side chat
+ */
+
+export class ChatSession {
+    /**
+     * @param {Object} options - Session options
+     * @param {import('../client.js').OblienClient} options.client - Oblien client instance
+     * @param {string} [options.sessionId] - Existing session ID
+     * @param {string} options.agentId - Agent ID to chat with
+     * @param {string} [options.workflowId] - Workflow ID (if using workflow)
+     * @param {boolean} [options.isGuest] - Is this a guest session
+     * @param {string} [options.namespace] - Guest namespace for rate limiting
+     * @param {Object} [options.workspace] - Workspace configuration
+     */
+    constructor(options) {
+        if (!options.client) {
+            throw new Error('Oblien client is required');
+        }
+
+        if (!options.agentId && !options.workflowId) {
+            throw new Error('Either agentId or workflowId is required');
+        }
+
+        this.client = options.client;
+        this.sessionId = options.sessionId || null;
+        this.agentId = options.agentId;
+        this.workflowId = options.workflowId;
+        this.isGuest = options.isGuest || false;
+        this.namespace = options.namespace;
+        this.workspace = options.workspace;
+        this.token = null;
+        this.data = null;
+    }
+
+    /**
+     * Create session and get token for client
+     * @returns {Promise<Object>} Session data with token for browser
+     */
+    async create() {
+        const payload = {
+            agent_id: this.agentId,
+            workflow_id: this.workflowId,
+            is_guest: this.isGuest,
+            namespace: this.namespace,
+            workspace: this.workspace,
+        };
+
+        this.data = await this.client.post('ai/session', payload);
+        this.sessionId = this.data.sessionId || this.data.session_id;
+        this.token = this.data.token || this.data.tokens?.token;
+
+        return {
+            sessionId: this.sessionId,
+            token: this.token,
+            agentId: this.data.agentId || this.agentId,
+            workflowId: this.data.workflowId || this.workflowId,
+            namespace: this.namespace,
+        };
+    }
+
+    /**
+     * Get existing session info
+     * @param {string} sessionId - Session ID
+     * @returns {Promise<Object>} Session details
+     */
+    async get(sessionId) {
+        this.data = await this.client.get(`ai/session/${sessionId || this.sessionId}`);
+        return this.data;
+    }
+
+
+    /**
+     * Delete session
+     * @param {string} [sessionId] - Session ID (uses instance sessionId if not provided)
+     * @returns {Promise<Object>} Deletion result
+     */
+    async delete(sessionId) {
+        const id = sessionId || this.sessionId;
+        if (!id) {
+            throw new Error('Session ID required');
+        }
+
+        return await this.client.delete(`ai/session/${id}`);
+    }
+
+    /**
+     * List all sessions
+     * @param {Object} [options] - Query options
+     * @returns {Promise<Array>} Array of sessions
+     */
+    async list(options = {}) {
+        const data = await this.client.get('ai/session', options);
+        return data.sessions || data;
+    }
+}
+
+export default ChatSession;

package/src/client.js

@@ -0,0 +1,189 @@
+/**
+ * Oblien Core Client
+ * Main client for authenticating and accessing Oblien API
+ */
+
+export class OblienClient {
+    /**
+     * @param {Object} config - Configuration options
+     * @param {string} config.apiKey - Your Oblien API key
+     * @param {string} [config.apiSecret] - Your Oblien API secret (for server-side)
+     * @param {string} [config.baseURL] - Base URL for API (default: https://api.oblien.com)
+     * @param {string} [config.version] - API version (default: v1)
+     */
+    constructor(config) {
+        if (!config || !config.apiKey) {
+            throw new Error('Oblien API key is required');
+        }
+
+        this.apiKey = config.apiKey;
+        this.apiSecret = config.apiSecret;
+        this.baseURL = config.baseURL || 'https://api.oblien.com';
+        this.version = config.version || 'v1';
+        this.token = null;
+        this.tokenExpiry = null;
+    }
+
+    /**
+     * Build full API URL
+     * @private
+     */
+    _buildURL(path) {
+        const cleanPath = path.startsWith('/') ? path.slice(1) : path;
+        return `${this.baseURL}/${this.version}/${cleanPath}`;
+    }
+
+    /**
+     * Authenticate and get access token
+     * @returns {Promise<string>} Access token
+     */
+    async authenticate() {
+        // Check if we have a valid token
+        if (this.token && this.tokenExpiry && Date.now() < this.tokenExpiry) {
+            return this.token;
+        }
+
+        try {
+            const response = await fetch(this._buildURL('auth/authenticate'), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    apiKey: this.apiKey,
+                    apiSecret: this.apiSecret,
+                }),
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.message || 'Authentication failed');
+            }
+
+            const data = await response.json();
+            this.token = data.token;
+            // Token expires in 1 hour, refresh 5 min before
+            this.tokenExpiry = Date.now() + (55 * 60 * 1000);
+
+            return this.token;
+        } catch (error) {
+            throw new Error(`Authentication error: ${error.message}`);
+        }
+    }
+
+    /**
+     * Get authentication headers
+     * @returns {Promise<Object>} Headers object
+     */
+    async getAuthHeaders() {
+        const token = await this.authenticate();
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        };
+    }
+
+    /**
+     * Make GET request
+     * @param {string} path - API path
+     * @param {Object} [params] - Query parameters
+     * @returns {Promise<any>} Response data
+     */
+    async get(path, params = {}) {
+        const headers = await this.getAuthHeaders();
+        const url = new URL(this._buildURL(path));
+        
+        // Add query parameters
+        Object.keys(params).forEach(key => {
+            if (params[key] !== undefined && params[key] !== null) {
+                url.searchParams.append(key, params[key]);
+            }
+        });
+
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers,
+        });
+
+        return this._handleResponse(response);
+    }
+
+    /**
+     * Make POST request
+     * @param {string} path - API path
+     * @param {Object} [body] - Request body
+     * @returns {Promise<any>} Response data
+     */
+    async post(path, body = {}) {
+        const headers = await this.getAuthHeaders();
+        
+        const response = await fetch(this._buildURL(path), {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        return this._handleResponse(response);
+    }
+
+    /**
+     * Make PUT request
+     * @param {string} path - API path
+     * @param {Object} [body] - Request body
+     * @returns {Promise<any>} Response data
+     */
+    async put(path, body = {}) {
+        const headers = await this.getAuthHeaders();
+        
+        const response = await fetch(this._buildURL(path), {
+            method: 'PUT',
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        return this._handleResponse(response);
+    }
+
+    /**
+     * Make DELETE request
+     * @param {string} path - API path
+     * @returns {Promise<any>} Response data
+     */
+    async delete(path) {
+        const headers = await this.getAuthHeaders();
+        
+        const response = await fetch(this._buildURL(path), {
+            method: 'DELETE',
+            headers,
+        });
+
+        return this._handleResponse(response);
+    }
+
+    /**
+     * Handle API response
+     * @private
+     */
+    async _handleResponse(response) {
+        const contentType = response.headers.get('content-type');
+        
+        // Handle non-JSON responses
+        if (!contentType || !contentType.includes('application/json')) {
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status} ${response.statusText}`);
+            }
+            return response.text();
+        }
+
+        const data = await response.json();
+
+        if (!response.ok) {
+            throw new Error(data.message || data.error || `API error: ${response.status}`);
+        }
+
+        return data;
+    }
+
+}
+
+export default OblienClient;