@nuraly/lumenui 0.1.0 → 0.2.2

package/dist/src/components/chatbot/providers/native-ws-provider.js

@@ -0,0 +1,544 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const DEFAULT_MESSAGE_TYPES = {
+    send: 'message:send',
+    response: 'message:response',
+    stream: 'message:stream',
+    error: 'message:error',
+    typingStart: 'typing:start',
+    typingEnd: 'typing:end',
+    ping: 'ping',
+    pong: 'pong',
+    toolCall: 'tool:call',
+    toolCallEnd: 'tool:end'
+};
+/**
+ * Native WebSocket provider for real-time chatbot communication.
+ *
+ * Uses the browser's built-in WebSocket API with a JSON envelope protocol.
+ * Zero additional dependencies — works with any backend that speaks plain
+ * WebSocket with JSON messages (Go, Rust, Python/FastAPI, Java/Quarkus, etc.).
+ *
+ * @example Basic usage
+ * ```typescript
+ * const provider = new NativeWebSocketProvider();
+ * await provider.connect({
+ *   url: 'wss://api.example.com/chat',
+ *   messageTypes: {
+ *     send: 'chat:message',
+ *     response: 'chat:response',
+ *     stream: 'chat:stream'
+ *   }
+ * });
+ * ```
+ *
+ * @example With auth via query params
+ * ```typescript
+ * const provider = new NativeWebSocketProvider();
+ * await provider.connect({
+ *   url: 'wss://api.example.com/chat',
+ *   queryParams: { token: 'my-jwt-token' },
+ *   messageTypes: {
+ *     send: 'ask',
+ *     response: 'answer'
+ *   }
+ * });
+ * ```
+ *
+ * @example Custom type field
+ * ```typescript
+ * const provider = new NativeWebSocketProvider();
+ * await provider.connect({
+ *   url: 'wss://api.example.com/ws',
+ *   typeField: 'event',
+ *   messageTypes: {
+ *     send: 'user_message',
+ *     response: 'bot_response',
+ *     stream: 'bot_chunk'
+ *   }
+ * });
+ * ```
+ */
+export class NativeWebSocketProvider {
+    constructor() {
+        this.id = 'native-websocket';
+        this.name = 'Native WebSocket Provider';
+        this.capabilities = {
+            streaming: true,
+            fileUpload: false,
+            modules: false,
+            functions: false
+        };
+        this.ws = null;
+        this.config = null;
+        this.connected = false;
+        this.responseResolvers = new Map();
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.pongTimer = null;
+        this.intentionalClose = false;
+        this.messageListeners = new Map();
+    }
+    connect(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            if (!config.url) {
+                throw new Error('WebSocket URL is required');
+            }
+            this.config = Object.assign(Object.assign({}, config), { messageTypes: Object.assign(Object.assign({}, DEFAULT_MESSAGE_TYPES), config.messageTypes), typeField: (_a = config.typeField) !== null && _a !== void 0 ? _a : 'type', autoReconnect: (_b = config.autoReconnect) !== null && _b !== void 0 ? _b : true, maxReconnectAttempts: (_c = config.maxReconnectAttempts) !== null && _c !== void 0 ? _c : 5, reconnectBaseDelay: (_d = config.reconnectBaseDelay) !== null && _d !== void 0 ? _d : 1000, reconnectMaxDelay: (_e = config.reconnectMaxDelay) !== null && _e !== void 0 ? _e : 30000, connectionTimeout: (_f = config.connectionTimeout) !== null && _f !== void 0 ? _f : 10000, responseTimeout: (_g = config.responseTimeout) !== null && _g !== void 0 ? _g : 30000, enableHeartbeat: (_h = config.enableHeartbeat) !== null && _h !== void 0 ? _h : true, heartbeatInterval: (_j = config.heartbeatInterval) !== null && _j !== void 0 ? _j : 30000, heartbeatTimeout: (_k = config.heartbeatTimeout) !== null && _k !== void 0 ? _k : 10000 });
+            this.intentionalClose = false;
+            this.reconnectAttempt = 0;
+            return this.createConnection();
+        });
+    }
+    createConnection() {
+        return new Promise((resolve, reject) => {
+            const config = this.config;
+            if (!config) {
+                reject(new Error('Provider not configured'));
+                return;
+            }
+            const url = this.buildUrl();
+            try {
+                this.ws = config.protocols
+                    ? new WebSocket(url, config.protocols)
+                    : new WebSocket(url);
+            }
+            catch (error) {
+                reject(new Error(`Failed to create WebSocket: ${error instanceof Error ? error.message : String(error)}`));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
+                    this.ws.close();
+                    reject(new Error('WebSocket connection timeout'));
+                }
+            }, config.connectionTimeout);
+            this.ws.onopen = () => {
+                var _a, _b;
+                clearTimeout(timeout);
+                this.connected = true;
+                this.reconnectAttempt = 0;
+                console.log('[NativeWebSocketProvider] Connected');
+                (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onConnectionChange) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+                this.startHeartbeat();
+                resolve();
+            };
+            this.ws.onclose = (event) => {
+                var _a, _b;
+                clearTimeout(timeout);
+                const wasConnected = this.connected;
+                this.connected = false;
+                this.stopHeartbeat();
+                console.log('[NativeWebSocketProvider] Disconnected:', event.code, event.reason);
+                if (wasConnected) {
+                    (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onConnectionChange) === null || _b === void 0 ? void 0 : _b.call(_a, false);
+                }
+                // Reject pending resolvers
+                for (const [id, resolver] of this.responseResolvers) {
+                    if (resolver.chunks.length > 0) {
+                        resolver.resolve(resolver.chunks.join(''));
+                    }
+                    else {
+                        resolver.reject(new Error('WebSocket connection closed'));
+                    }
+                    this.responseResolvers.delete(id);
+                }
+                if (!this.intentionalClose && wasConnected) {
+                    this.attemptReconnect();
+                }
+                else if (!wasConnected) {
+                    // Connection never established
+                    reject(new Error(`WebSocket connection failed (code: ${event.code})`));
+                }
+            };
+            this.ws.onerror = (event) => {
+                console.error('[NativeWebSocketProvider] Error:', event);
+            };
+            this.ws.onmessage = (event) => {
+                this.handleMessage(event);
+            };
+        });
+    }
+    buildUrl() {
+        const config = this.config;
+        if (!config)
+            return '';
+        let url = config.url;
+        const params = config.queryParams;
+        if (params && Object.keys(params).length > 0) {
+            const separator = url.includes('?') ? '&' : '?';
+            const query = Object.entries(params)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+                .join('&');
+            url = `${url}${separator}${query}`;
+        }
+        return url;
+    }
+    handleMessage(event) {
+        var _a, _b, _c;
+        if (!this.config)
+            return;
+        const data = this.parseMessageData(event.data);
+        if (!data)
+            return;
+        const typeField = (_a = this.config.typeField) !== null && _a !== void 0 ? _a : 'type';
+        const messageType = data[typeField];
+        const types = this.config.messageTypes;
+        if (messageType === types.pong) {
+            this.handlePong();
+            return;
+        }
+        if (messageType === types.ping) {
+            this.send(types.pong, { timestamp: Date.now() });
+            return;
+        }
+        if (messageType === types.toolCall) {
+            const toolName = data.name || data.toolName || data.function || 'unknown';
+            (_b = this.onToolCall) === null || _b === void 0 ? void 0 : _b.call(this, toolName);
+            this.dispatchToListeners(messageType, data);
+            return;
+        }
+        if (messageType === types.toolCallEnd) {
+            (_c = this.onToolCallEnd) === null || _c === void 0 ? void 0 : _c.call(this);
+            this.dispatchToListeners(messageType, data);
+            return;
+        }
+        this.dispatchToListeners(messageType, data);
+        if (messageType === types.response) {
+            this.handleResponseMessage(data);
+            return;
+        }
+        if (messageType === types.stream) {
+            this.handleStreamMessage(data);
+            return;
+        }
+        if (messageType === types.error) {
+            this.handleErrorMessage(data);
+        }
+    }
+    parseMessageData(rawData) {
+        try {
+            return typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
+        }
+        catch (_a) {
+            console.warn('[NativeWebSocketProvider] Non-JSON message received:', rawData);
+            return null;
+        }
+    }
+    dispatchToListeners(messageType, data) {
+        if (!messageType)
+            return;
+        const listeners = this.messageListeners.get(messageType);
+        if (!listeners)
+            return;
+        for (const cb of listeners) {
+            try {
+                cb(data);
+            }
+            catch (e) {
+                console.error('[NativeWebSocketProvider] Listener error:', e);
+            }
+        }
+    }
+    handleResponseMessage(data) {
+        const messageId = this.extractMessageId(data);
+        const resolver = this.responseResolvers.get(messageId) || this.getLatestResolver();
+        if (resolver) {
+            const message = this.extractMessageContent(data);
+            resolver.resolve(message);
+            this.responseResolvers.delete(messageId);
+        }
+    }
+    handleStreamMessage(data) {
+        const messageId = this.extractMessageId(data);
+        const resolver = this.responseResolvers.get(messageId) || this.getLatestResolver();
+        if (resolver) {
+            resolver.isStreaming = true;
+            const chunk = this.extractMessageContent(data);
+            resolver.chunks.push(chunk);
+        }
+    }
+    handleErrorMessage(data) {
+        const messageId = this.extractMessageId(data);
+        const resolver = this.responseResolvers.get(messageId) || this.getLatestResolver();
+        if (resolver) {
+            const errorMsg = data.error || data.message || 'Unknown error';
+            resolver.reject(new Error(errorMsg));
+            this.responseResolvers.delete(messageId);
+        }
+    }
+    getLatestResolver() {
+        const keys = Array.from(this.responseResolvers.keys());
+        const lastKey = keys.at(-1);
+        if (lastKey !== undefined) {
+            return this.responseResolvers.get(lastKey);
+        }
+        return null;
+    }
+    extractMessageId(data) {
+        return data.messageId || data.id || data.executionId || 'default';
+    }
+    extractMessageContent(data) {
+        var _a, _b, _c;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.extractMessage) {
+            return this.config.extractMessage(data);
+        }
+        if (typeof data === 'string')
+            return data;
+        if (data.message)
+            return data.message;
+        if (data.text)
+            return data.text;
+        if (data.response)
+            return data.response;
+        if (data.content)
+            return data.content;
+        if ((_b = data.data) === null || _b === void 0 ? void 0 : _b.message)
+            return data.data.message;
+        if ((_c = data.data) === null || _c === void 0 ? void 0 : _c.output)
+            return JSON.stringify(data.data.output);
+        return JSON.stringify(data);
+    }
+    // --- Heartbeat ---
+    startHeartbeat() {
+        var _a;
+        if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableHeartbeat))
+            return;
+        this.stopHeartbeat();
+        const types = this.config.messageTypes;
+        this.heartbeatTimer = setInterval(() => {
+            var _a, _b, _c;
+            if (this.connected && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                this.send(types.ping, { timestamp: Date.now() });
+                // Start pong timeout
+                this.pongTimer = setTimeout(() => {
+                    var _a;
+                    console.warn('[NativeWebSocketProvider] Heartbeat timeout — closing connection');
+                    (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close(4000, 'Heartbeat timeout');
+                }, (_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.heartbeatTimeout) !== null && _c !== void 0 ? _c : 10000);
+            }
+        }, this.config.heartbeatInterval);
+    }
+    handlePong() {
+        if (this.pongTimer) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.pongTimer) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
+    // --- Reconnection ---
+    attemptReconnect() {
+        var _a, _b, _c, _d, _e, _f;
+        if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.autoReconnect))
+            return;
+        const maxAttempts = (_b = this.config.maxReconnectAttempts) !== null && _b !== void 0 ? _b : 5;
+        if (this.reconnectAttempt >= maxAttempts) {
+            console.error('[NativeWebSocketProvider] Max reconnection attempts reached');
+            return;
+        }
+        this.reconnectAttempt++;
+        const base = (_c = this.config.reconnectBaseDelay) !== null && _c !== void 0 ? _c : 1000;
+        const max = (_d = this.config.reconnectMaxDelay) !== null && _d !== void 0 ? _d : 30000;
+        const delay = Math.min(base * Math.pow(2, this.reconnectAttempt - 1) + Math.random() * base, max);
+        console.log(`[NativeWebSocketProvider] Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempt}/${maxAttempts})`);
+        (_f = (_e = this.config).onReconnectAttempt) === null || _f === void 0 ? void 0 : _f.call(_e, this.reconnectAttempt, maxAttempts);
+        this.reconnectTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.createConnection();
+                console.log('[NativeWebSocketProvider] Reconnected successfully');
+            }
+            catch (_a) {
+                // onclose handler will trigger next attempt
+            }
+        }), delay);
+    }
+    // --- Provider interface ---
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.intentionalClose = true;
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+                this.reconnectTimer = null;
+            }
+            this.stopHeartbeat();
+            if (this.ws) {
+                this.ws.close(1000, 'Client disconnect');
+                this.ws = null;
+            }
+            this.connected = false;
+            this.responseResolvers.clear();
+            this.messageListeners.clear();
+            console.log('[NativeWebSocketProvider] Disconnected');
+        });
+    }
+    isConnected() {
+        var _a;
+        return this.connected && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+    sendMessage(text, context) {
+        return __asyncGenerator(this, arguments, function* sendMessage_1() {
+            if (!this.connected || !this.ws || !this.config) {
+                yield yield __await(this.formatError('Not Connected', 'WebSocket is not connected. Please check your connection.'));
+                return yield __await(void 0);
+            }
+            const messageId = `msg_${Date.now()}_${crypto.randomUUID().slice(0, 9)}`;
+            const payload = this.buildPayload(text, context, messageId);
+            try {
+                const responsePromise = new Promise((resolve, reject) => {
+                    var _a, _b;
+                    this.responseResolvers.set(messageId, {
+                        resolve,
+                        reject,
+                        chunks: [],
+                        isStreaming: false
+                    });
+                    setTimeout(() => {
+                        const resolver = this.responseResolvers.get(messageId);
+                        if (resolver) {
+                            if (resolver.chunks.length > 0) {
+                                resolve(resolver.chunks.join(''));
+                            }
+                            else {
+                                reject(new Error('Response timeout'));
+                            }
+                            this.responseResolvers.delete(messageId);
+                        }
+                    }, (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.responseTimeout) !== null && _b !== void 0 ? _b : 30000);
+                });
+                // Send the message
+                const types = this.config.messageTypes;
+                this.send(types.send, Object.assign(Object.assign({}, payload), { messageId }));
+                // If streaming is enabled, yield chunks as they arrive
+                if (this.config.messageTypes.stream) {
+                    const resolver = this.responseResolvers.get(messageId);
+                    let lastYieldedLength = 0;
+                    const checkInterval = setInterval(() => {
+                        if (resolver && resolver.chunks.length > lastYieldedLength) {
+                            lastYieldedLength = resolver.chunks.length;
+                        }
+                    }, 50);
+                    try {
+                        const response = yield __await(responsePromise);
+                        clearInterval(checkInterval);
+                        yield yield __await(response);
+                    }
+                    catch (error) {
+                        clearInterval(checkInterval);
+                        throw error;
+                    }
+                }
+                else {
+                    const response = yield __await(responsePromise);
+                    yield yield __await(response);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                yield yield __await(this.formatError('WebSocket Error', errorMessage));
+                this.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    // --- Public convenience methods ---
+    /**
+     * Send a typed JSON message over the WebSocket.
+     */
+    send(type, payload) {
+        var _a;
+        if (this.ws && this.ws.readyState === WebSocket.OPEN && this.config) {
+            const typeField = (_a = this.config.typeField) !== null && _a !== void 0 ? _a : 'type';
+            const message = Object.assign({ [typeField]: type }, payload);
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Subscribe to messages of a specific type. Returns an unsubscribe function.
+     */
+    onMessage(type, callback) {
+        var _a;
+        if (!this.messageListeners.has(type)) {
+            this.messageListeners.set(type, new Set());
+        }
+        (_a = this.messageListeners.get(type)) === null || _a === void 0 ? void 0 : _a.add(callback);
+        return () => {
+            const listeners = this.messageListeners.get(type);
+            if (listeners) {
+                listeners.delete(callback);
+                if (listeners.size === 0) {
+                    this.messageListeners.delete(type);
+                }
+            }
+        };
+    }
+    /**
+     * Get the underlying WebSocket instance for advanced usage.
+     */
+    getWebSocket() {
+        return this.ws;
+    }
+    // --- Protected helpers ---
+    buildPayload(text, context, messageId) {
+        var _a, _b, _c;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.buildPayload) {
+            const customPayload = this.config.buildPayload(text, context);
+            return Object.assign(Object.assign({}, customPayload), { messageId });
+        }
+        return {
+            messageId,
+            message: text,
+            text,
+            threadId: (_b = context.currentThread) === null || _b === void 0 ? void 0 : _b.id,
+            modules: context.selectedModules,
+            metadata: context.metadata,
+            files: (_c = context.uploadedFiles) === null || _c === void 0 ? void 0 : _c.map(f => ({
+                id: f.id,
+                name: f.name,
+                type: f.type,
+                url: f.url
+            }))
+        };
+    }
+    formatError(title, description) {
+        return `[ERROR_START][ERROR_TITLE_START]${title}[ERROR_TITLE_END]${description}[ERROR_END]`;
+    }
+    onError(error) {
+        console.error('[NativeWebSocketProvider] Error:', error);
+    }
+}
+//# sourceMappingURL=native-ws-provider.js.map

package/dist/src/components/chatbot/providers/openai-provider.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import type { ChatbotProvider, ProviderCapabilities, ProviderConfig, ChatbotContext } from '../core/types.js';
+import type { ChatbotFile, ChatbotModule } from '../chatbot.types.js';
+/**
+ * OpenAI provider for ChatGPT integration
+ */
+export declare class OpenAIProvider implements ChatbotProvider {
+    readonly id = "openai";
+    readonly name = "OpenAI";
+    readonly capabilities: ProviderCapabilities;
+    private apiKey;
+    private apiUrl;
+    private model;
+    private temperature;
+    private maxTokens?;
+    private connected;
+    connect(config: ProviderConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    sendMessage(text: string, context: ChatbotContext): AsyncIterator<string>;
+    getAvailableModules(): Promise<ChatbotModule[]>;
+    callModule(moduleId: string, params: any): Promise<any>;
+    uploadFile(file: File): Promise<ChatbotFile>;
+    onError(error: Error): void;
+    private buildMessages;
+    private determineFileType;
+}
+//# sourceMappingURL=openai-provider.d.ts.map