oblien 1.2.7 → 2.0.0

package/src/chat/index.js

@@ -1,704 +0,0 @@
-/**
- * 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
-     * @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) {
-        const session = new ChatSession({
-            client: this.client,
-        });
-
-        return await session.create(options);
-    }
-
-    /**
-     * Create a guest session based on IP and fingerprint (dual-layer identification)
-     * 
-     * Namespace handling:
-     * - If `namespace` is provided: Uses it as the session namespace
-     * - If `namespace` is NOT provided: Uses guest's auto-generated namespace (based on IP)
-     * - `endUserId`: Optional identifier for your end user (tracked separately)
-     * 
-     * @param {Object} options - Guest session options
-     * @param {string} options.ip - Client IP address (required)
-     * @param {string} [options.fingerprint] - Client fingerprint for identification
-     * @param {string} options.agentId - Agent ID to chat with
-     * @param {string} [options.workflowId] - Workflow ID
-     * @param {string} [options.namespace] - Custom namespace (e.g., 'my-app-guests'). If not provided, uses auto-generated guest namespace
-     * @param {string} [options.endUserId] - Your end user's ID (e.g., from your database)
-     * @param {Object} [options.metadata] - Additional guest metadata (userAgent, etc.)
-     * @param {Object} [options.workspace] - Workspace configuration
-     * @returns {Promise<Object>} Session data with token and guest info
-     * 
-     * @example
-     * // Simple guest session (auto namespace)
-     * await chat.createGuestSession({
-     *   ip: '1.2.3.4',
-     *   agentId: 'my-agent-id'
-     * });
-     * 
-     * @example
-     * // With custom namespace and end user ID
-     * await chat.createGuestSession({
-     *   ip: '1.2.3.4',
-     *   fingerprint: 'abc123',
-     *   agentId: 'my-agent-id',
-     *   namespace: 'my-app-guests',
-     *   endUserId: 'user_12345'
-     * });
-     */
-    async createGuestSession(options) {
-        const {
-            ip,
-            fingerprint,
-            agentId,
-            workflowId,
-            namespace,
-            endUserId,
-            metadata = {},
-            workspace,
-            useLocalStorage = false
-        } = options;
-
-        if (!ip) {
-            throw new Error('IP address is required for guest sessions');
-        }
-
-        if (!agentId) {
-            throw new Error('Agent ID is required for guest sessions');
-        }
-
-        // Create session via API (API will handle guest creation in Oblien database)
-        const session = new ChatSession({
-            client: this.client,
-        });
-
-        const sessionData = await session.create({
-            agentId,
-            workflowId,
-            workspace,
-            isGuest: true,
-            namespace: namespace,
-            ipAddress: ip,
-            userAgent: metadata.userAgent,
-            fingerprint: fingerprint,
-            endUserId: endUserId,
-        });
-
-        // If using local storage, also store guest locally for caching
-        if (useLocalStorage) {
-            const guest = await this.guestManager.getOrCreateGuest(ip, fingerprint, {
-                ...metadata,
-                fingerprint,
-                ip,
-            });
-            
-            await this.guestManager.addSession(guest.id, sessionData.sessionId);
-        }
-
-        return sessionData
-    }
-
-    /**
-     * Get guest sessions by namespace, IP, or fingerprint from Oblien API (server-side)
-     * @param {string|Object} options - Namespace string or query options object
-     * @param {string} [options.ip] - IP address
-     * @param {string} [options.fingerprint] - Client fingerprint
-     * @param {string} [options.namespace] - Guest namespace
-     * @returns {Promise<Object|null>} Guest object with sessions array or null
-     * 
-     * @example
-     * // Get by namespace (string)
-     * const guest = await chat.getGuest('guest-1-2-3-4');
-     * 
-     * @example
-     * // Get by IP and fingerprint (object)
-     * const guest = await chat.getGuest({ ip: '1.2.3.4', fingerprint: 'abc123' });
-     * 
-     * @example
-     * // Get by namespace (object)
-     * const guest = await chat.getGuest({ namespace: 'guest-1-2-3-4' });
-     */
-    async getGuest(options, getSessions = false) {
-        // Handle string usage: getGuest('namespace')
-        if (typeof options === 'string') {
-            options = { namespace: options };
-        }
-
-        const agentId = options.agentId || options.agent_id;
-        const sessionId = options.sessionId || options.session_id;
-        const guestId = options.guestId || options.namespace;
-        const ip = options.ip;
-        const fingerprint = options.fingerprint;
-
-        if (!agentId && !sessionId && !guestId) {
-            throw new Error('Either agentId, sessionId, or guestId is required');
-        }
-
-        try {
-            const response = await this.client.post(getSessions ? `ai/guest/sessions` : `ai/guest/info`, {
-                ip,
-                fingerprint,
-                namespace: guestId,
-                agent_id: agentId,
-                session_id: sessionId,
-            });
-            return response;
-        } catch (error) {
-            // Return null if guest not found (404)
-            if (error.message?.includes('not_found') || error.message?.includes('404')) {
-                return null;
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Get guest from local cache/storage (for internal use)
-     * @param {string} ip - IP address
-     * @param {string} [fingerprint] - Client fingerprint (optional)
-     * @returns {Promise<Object|null>} Guest object from cache or null
-     */
-    async getGuestFromCache(ip, fingerprint = null) {
-        // Try fingerprint first if provided
-        if (fingerprint) {
-            const guestIdByFingerprint = await this.guestManager.storage.get(`fingerprint:${fingerprint}`);
-            if (guestIdByFingerprint) {
-                const guest = await this.guestManager.getGuest(guestIdByFingerprint);
-                if (guest) return guest;
-            }
-        }
-
-        // Fallback to IP
-        if (ip) {
-            const guestIdByIp = await this.guestManager.storage.get(`ip:${ip}`);
-            if (guestIdByIp) {
-                const guest = await this.guestManager.getGuest(guestIdByIp);
-                if (guest) return guest;
-            }
-
-            // Fallback to old method (generate guest ID from IP)
-            const fallbackGuestId = this.guestManager.generateGuestId(ip);
-            return await this.guestManager.getGuest(fallbackGuestId);
-        }
-
-        return null;
-    }
-
-    /**
-     * Send a message in a chat session
-     * Hybrid mode: Works with session token OR client credentials
-     * 
-     * @param {Object} options - Send options
-     * @param {string} [options.token] - Session token (optional, uses client credentials if not provided)
-     * @param {string} options.message - Message to send
-     * @param {string} [options.uploadId] - Upload ID for attached files
-     * @param {Array} [options.files] - File attachments (alternative to uploadId)
-     * @param {boolean} [options.stream] - Enable streaming response
-     * @param {Function} [options.onChunk] - Callback for streaming chunks (data) => void
-     * @param {Function} [options.onError] - Callback for errors (error) => void
-     * @param {Function} [options.onComplete] - Callback when stream completes () => void
-     * @param {Object} [options.metadata] - Additional metadata
-     * @returns {Promise<Object>} Response data
-     */
-    async send(options = {}) {
-        const {
-            token,
-            message,
-            uploadId,
-            files,
-            stream = false,
-            onChunk,
-            onError,
-            onComplete,
-            metadata = {}
-        } = options;
-
-        if (!message || !message.trim()) {
-            throw new Error('Message is required');
-        }
-
-        const payload = {
-            message,
-            stream,
-            ...metadata,
-        };
-
-        if (uploadId) {
-            payload.upload_id = uploadId;
-        }
-
-        if (files) {
-            payload.files = files;
-        }
-
-        // Build headers - use token if provided, otherwise use client credentials
-        const headers = {
-            ...this.client.getAuthHeaders(),
-            'Content-Type': 'application/json',
-        };
-
-        if (token) {
-            headers['Authorization'] = `Bearer ${token}`;
-        }
-
-        const url = this.client._buildURL('ai/chat/send');
-
-        if (stream) {
-            // Handle streaming response
-            const response = await fetch(url, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(payload),
-            });
-
-            if (!response.ok) {
-                const error = await response.text();
-                throw new Error(error || `API error: ${response.status}`);
-            }
-
-            // Process SSE stream
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = '';
-
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-
-                    if (done) {
-                        if (onComplete) onComplete();
-                        break;
-                    }
-
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split('\n');
-                    buffer = lines.pop() || '';
-
-                    for (const line of lines) {
-                        if (line.trim() === '') continue;
-
-                        try {
-                            const data = JSON.parse(line);
-                            if (onChunk) onChunk(data);
-                        } catch (e) {
-                            // Skip non-JSON lines (SSE format)
-                            if (line.startsWith('data: ')) {
-                                try {
-                                    const jsonStr = line.substring(6);
-                                    const data = JSON.parse(jsonStr);
-                                    if (onChunk) onChunk(data);
-                                } catch (parseError) {
-                                    console.warn('Failed to parse chunk:', line);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return { success: true, stream: true };
-            } catch (error) {
-                if (onError) onError(error);
-                throw error;
-            }
-        } else {
-            // Regular non-streaming request
-            const response = await fetch(url, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(payload),
-            });
-
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({ message: response.statusText }));
-                throw new Error(error.message || error.error || `API error: ${response.status}`);
-            }
-
-            return await response.json();
-        }
-    }
-
-    /**
-     * Upload files for a chat session
-     * Hybrid mode: Works with session token OR client credentials
-     * 
-     * @param {Object} options - Upload options
-     * @param {string} [options.token] - Session token (optional, uses client credentials if not provided)
-     * @param {Array|Object} options.files - Files to upload
-     * @param {Object} [options.metadata] - Additional metadata
-     * @returns {Promise<Object>} Upload result with uploadId
-     */
-    async upload(options = {}) {
-        const { token, files, metadata } = options;
-
-        if (!files || (Array.isArray(files) && files.length === 0)) {
-            throw new Error('Files are required');
-        }
-
-        const formData = new FormData();
-
-        // Handle both single file and array of files
-        const fileArray = Array.isArray(files) ? files : [files];
-
-        fileArray.forEach((file, index) => {
-            if (file instanceof File || file instanceof Blob) {
-                formData.append('files', file);
-            } else if (file.path && file.buffer) {
-                // Node.js file object
-                formData.append('files', file.buffer, file.originalname || file.path);
-            } else {
-                throw new Error(`Invalid file at index ${index}`);
-            }
-        });
-
-        // Add any additional options
-        if (metadata) {
-            formData.append('metadata', JSON.stringify(metadata));
-        }
-
-        // Build headers - use token if provided, otherwise use client credentials
-        const headers = {
-            ...this.client.getAuthHeaders(),
-        };
-
-        if (token) {
-            headers['Authorization'] = `Bearer ${token}`;
-        }
-
-        // Remove Content-Type for FormData (browser will set it with boundary)
-        delete headers['Content-Type'];
-
-        const url = this.client._buildURL('ai/chat/upload');
-
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: formData,
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ message: response.statusText }));
-            throw new Error(error.message || error.error || `API error: ${response.status}`);
-        }
-
-        return await response.json();
-    }
-
-    /**
-     * Get session info (server-side)
-     * @param {string} sessionId - Session ID
-     * @returns {Promise<Object>} Session details
-     */
-    async getSession(sessionId) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.get(`ai/session/${sessionId}`);
-    }
-
-    /**
-     * Create a session token for client-side access (server-side)
-     * @param {string} sessionId - Session ID
-     * @returns {Promise<Object>} Token data (accessToken, refreshToken)
-     */
-    async createSessionToken(sessionId) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.post(`ai/session/${sessionId}/token/create`);
-    }
-
-    /**
-     * Revoke a session token (server-side)
-     * @param {string} sessionId - Session ID
-     * @returns {Promise<Object>} Revocation result
-     */
-    async revokeSessionToken(sessionId) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.post(`ai/session/${sessionId}/token/revoke`);
-    }
-
-    /**
-     * Get session history by session ID (server-side)
-     * @param {string} sessionId - Session ID
-     * @param {Object} [options] - Query options
-     * @param {number} [options.limit] - Number of messages (max 100)
-     * @param {number} [options.offset] - Offset for pagination
-     * @returns {Promise<Object>} Session history with messages
-     */
-    async getSessionHistory(sessionId, options = {}) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-
-        const params = new URLSearchParams();
-        if (options.limit) params.append('limit', Math.min(options.limit, 100).toString());
-        if (options.offset) params.append('offset', Math.max(options.offset, 0).toString());
-
-        const url = `ai/session/${sessionId}/history${params.toString() ? `?${params.toString()}` : ''}`;
-        return await this.client.get(url);
-    }
-
-    /**
-     * Ban a user from a session (server-side)
-     * @param {string} sessionId - Session ID
-     * @param {Object} [options] - Ban options
-     * @param {string} [options.reason] - Reason for ban
-     * @returns {Promise<Object>} Ban result
-     */
-    async banUser(sessionId, options = {}) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.post(`ai/session/${sessionId}/ban`, options);
-    }
-
-    /**
-     * Unban a user from a session (server-side)
-     * @param {string} sessionId - Session ID
-     * @returns {Promise<Object>} Unban result
-     */
-    async unbanUser(sessionId) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.post(`ai/session/${sessionId}/unban`);
-    }
-
-    /**
-     * Lock or unlock a session (server-side)
-     * @param {string} sessionId - Session ID
-     * @param {Object} [options] - Lock options
-     * @param {boolean} [options.locked] - Lock state (true to lock, false to unlock)
-     * @returns {Promise<Object>} Lock result
-     */
-    async lockSession(sessionId, options = {}) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        return await this.client.post(`ai/session/${sessionId}/lock`, options);
-    }
-
-    /**
-     * List sessions (server-side)
-     * @param {Object} [options] - Query options
-     * @param {string} [options.namespace] - Filter by namespace
-     * @param {string} [options.agentId] - Filter by agent ID
-     * @param {string} [options.endUserId] - Filter by end user ID
-     * @param {number} [options.limit] - Number of results (max 100)
-     * @param {number} [options.offset] - Offset for pagination
-     * @param {string} [options.search] - Search in title and user ID
-     * @param {string} [options.sortBy] - Sort by 'time' or 'tokens'
-     * @param {string} [options.sortOrder] - 'asc' or 'desc'
-     * @param {boolean} [options.includeStats] - Include message count and tokens
-     * @param {boolean} [options.includeGuests] - Include guest information
-     * @returns {Promise<Array>} Array of sessions
-     */
-    async listSessions(options = {}) {
-        const session = new ChatSession({
-            client: this.client,
-        });
-
-        return await session.list(options);
-    }
-
-    /**
-     * Delete a session (server-side)
-     * @param {string} sessionId - Session ID to delete
-     * @returns {Promise<Object>} Deletion result
-     */
-    async deleteSession(sessionId) {
-        if (!sessionId) {
-            throw new Error('Session ID is required');
-        }
-        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();
-    }
-
-    /**
-     * Get guest usage information (server-side)
-     * @param {string} namespace - Guest namespace
-     * @param {string} [agentId] - Agent ID (optional)
-     * @returns {Promise<Object>} Usage information for the guest
-     */
-    async getGuestUsage(namespace, agentId = null) {
-        if (!namespace) {
-            throw new Error('Namespace is required');
-        }
-
-        const params = new URLSearchParams();
-        params.append('namespace', namespace);
-        if (agentId) params.append('agent_id', agentId);
-
-        return await this.client.get(`ai/guest/usage?${params.toString()}`);
-    }
-
-    /**
-     * Get cache statistics (admin/monitoring)
-     * @returns {Promise<Object>} Cache statistics
-     */
-    async getCacheStatistics() {
-        const data = await this.client.get('ai/guest/cache-stats');
-        return data;
-    }
-
-    /**
-     * Refresh session token (client-side)
-     * Uses refresh token to get new access token
-     * 
-     * @param {string} refreshToken - Refresh token from session
-     * @returns {Promise<Object>} New tokens
-     */
-    async refreshToken(refreshToken) {
-        if (!refreshToken) {
-            throw new Error('Refresh token is required');
-        }
-
-        const url = this.client._buildURL('ai/session/token/refresh');
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${refreshToken}`,
-                'Content-Type': 'application/json',
-            },
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ message: response.statusText }));
-            throw new Error(error.message || error.error || `API error: ${response.status}`);
-        }
-
-        return await response.json();
-    }
-
-    /**
-     * Get chat history (client-side)
-     * Uses session token to get chat history
-     * 
-     * @param {Object} options - History options
-     * @param {string} options.token - Session token (required for client-side)
-     * @param {string} [options.namespace] - Namespace filter
-     * @param {number} [options.limit] - Number of messages (max 50)
-     * @param {number} [options.offset] - Offset for pagination
-     * @returns {Promise<Object>} Chat history with messages
-     */
-    async getHistory(options = {}) {
-        const { token, namespace, limit = 50, offset = 0 } = options;
-
-        if (!token) {
-            throw new Error('Session token is required for client-side history');
-        }
-
-        const params = new URLSearchParams();
-        if (namespace) params.append('namespace', namespace);
-        params.append('limit', Math.min(limit, 50).toString());
-        params.append('offset', Math.max(offset, 0).toString());
-
-        const url = `${this.client._buildURL('ai/session/history')}?${params.toString()}`;
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Content-Type': 'application/json',
-            },
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ message: response.statusText }));
-            throw new Error(error.message || error.error || `API error: ${response.status}`);
-        }
-
-        return await response.json();
-    }
-
-    /**
-     * Prepare session (client-side)
-     * Prepares session for app/container usage
-     * 
-     * @param {Object} options - Prepare options
-     * @param {string} options.token - Session token (required for client-side)
-     * @returns {Promise<Object>} Preparation result
-     */
-    async prepareSession(options = {}) {
-        const { token } = options;
-
-        if (!token) {
-            throw new Error('Session token is required for client-side prepare');
-        }
-
-        const url = this.client._buildURL('ai/session/prepare');
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Content-Type': 'application/json',
-            },
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ message: response.statusText }));
-            throw new Error(error.message || error.error || `API error: ${response.status}`);
-        }
-
-        return await response.json();
-    }
-}
-
-export { ChatSession } from './session.js';
-export default OblienChat;