@nuraly/lumenui 0.2.1 → 0.3.2

package/dist/src/components/chatbot/providers/workflow-socket-provider.js

@@ -0,0 +1,484 @@
+/**
+ * @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]); }
+};
+import { io } from 'socket.io-client';
+import { ChatbotFileType } from '../chatbot.types.js';
+/**
+ * Workflow Socket Provider for chatbot
+ *
+ * Triggers workflows via HTTP and receives real-time updates via socket.io.
+ * CHAT_OUTPUT nodes in the workflow send messages to the chatbot in real-time.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const provider = new WorkflowSocketProvider();
+ * await provider.connect({
+ *   workflowId: 'abc-123-def'
+ * });
+ *
+ * const controller = new ChatbotCoreController({
+ *   provider
+ * });
+ * ```
+ *
+ * @example With custom input builder
+ * ```typescript
+ * const provider = new WorkflowSocketProvider();
+ * await provider.connect({
+ *   workflowId: 'abc-123-def',
+ *   buildInput: (text, context) => ({
+ *     message: text,
+ *     threadId: context.currentThread?.id,
+ *     userId: context.metadata.userId
+ *   })
+ * });
+ * ```
+ */
+export class WorkflowSocketProvider {
+    constructor() {
+        this.id = 'workflow-socket';
+        this.name = 'Workflow Socket Provider';
+        this.capabilities = {
+            streaming: true,
+            fileUpload: true,
+            modules: true,
+            functions: false
+        };
+        this.socket = null;
+        this.config = null;
+        this.connected = false;
+        // Session ID for this provider instance - used as threadId fallback for context memory
+        this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+        // Track active executions and their message handlers
+        this.activeExecutions = new Map();
+    }
+    connect(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!config.workflowId) {
+                throw new Error('Workflow ID is required');
+            }
+            this.config = Object.assign({ socketUrl: config.socketUrl || (typeof window !== 'undefined' ? window.location.origin : 'http://localhost:8000'), socketPath: config.socketPath || '/__nk_socketio/', triggerEndpoint: config.triggerEndpoint || '/api/v1/workflows/{workflowId}/trigger/chat', responseTimeout: config.responseTimeout || 60000 }, config);
+            // Connect to the workflow socket namespace so socket.ts handler runs and
+            // registers this socket in the execution bridge's subscriber map.
+            const socketNs = `${this.config.socketUrl}/nk/apps/workflows/:workflowId`;
+            this.socket = io(socketNs, {
+                path: this.config.socketPath,
+                query: { __params: JSON.stringify({ workflowId: this.config.workflowId }) },
+                transports: ['websocket', 'polling'],
+                autoConnect: true,
+                reconnection: true,
+                reconnectionAttempts: 5
+            });
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Socket connection timeout'));
+                }, 10000);
+                this.socket.on('connect', () => {
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    console.log('[WorkflowSocketProvider] Connected:', this.socket.id);
+                    // Subscribe to workflow room so the execution bridge routes events to this socket
+                    this.subscribeToWorkflow(this.config.workflowId);
+                    resolve();
+                });
+                this.socket.on('connect_error', (error) => {
+                    clearTimeout(timeout);
+                    console.error('[WorkflowSocketProvider] Connection error:', error);
+                    reject(error);
+                });
+                this.socket.on('disconnect', (reason) => {
+                    this.connected = false;
+                    console.log('[WorkflowSocketProvider] Disconnected:', reason);
+                });
+                // Setup event listeners
+                this.setupEventListeners();
+            });
+        });
+    }
+    subscribeToWorkflow(workflowId) {
+        if (this.socket) {
+            this.socket.emit('nk:subscribe:workflow', { workflowId });
+            console.log('[WorkflowSocketProvider] Subscribed to workflow:', workflowId);
+        }
+    }
+    subscribeToExecution(executionId) {
+        if (this.socket) {
+            this.socket.emit('nk:subscribe:execution', { executionId });
+            console.log('[WorkflowSocketProvider] Subscribed to execution:', executionId);
+        }
+    }
+    setupEventListeners() {
+        if (!this.socket)
+            return;
+        // Log every incoming event for diagnostics
+        this.socket.onAny((event, ...args) => {
+            console.log('[WorkflowSocketProvider] RAW event:', event, args[0]);
+        });
+        // LumenJS wraps server→client pushes as 'nk:data' { event, data }.
+        // Handle them here directly — rawSocket.emit also delivers direct events below.
+        this.socket.on('nk:data', (wrapper) => {
+            if ((wrapper === null || wrapper === void 0 ? void 0 : wrapper.event) && wrapper.data) {
+                this._handleEvent(wrapper.event, wrapper.data);
+            }
+        });
+        // Direct events emitted via rawSocket.emit(event, data) in socket.ts
+        this.socket.on('execution:chat-message', (d) => this._handleEvent('execution:chat-message', d));
+        this.socket.on('execution:started', (d) => this._handleEvent('execution:started', d));
+        this.socket.on('execution:completed', (d) => this._handleEvent('execution:completed', d));
+        this.socket.on('execution:failed', (d) => this._handleEvent('execution:failed', d));
+        this.socket.on('execution:node-started', (d) => this._handleEvent('execution:node-started', d));
+        this.socket.on('execution:node-completed', (d) => this._handleEvent('execution:node-completed', d));
+    }
+    _handleEvent(event, data) {
+        var _a, _b, _c, _d, _e;
+        switch (event) {
+            case 'execution:chat-message': {
+                const executionId = data.executionId;
+                const message = data.message;
+                console.log('[WorkflowSocketProvider] Chat message received:', executionId, message);
+                if (!executionId || !message)
+                    return;
+                const execution = this.activeExecutions.get(executionId);
+                if (!execution) {
+                    (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onMessage) === null || _b === void 0 ? void 0 : _b.call(_a, message);
+                    return;
+                }
+                if (!execution.completed)
+                    execution.messages.push(message);
+                break;
+            }
+            case 'execution:started':
+                console.log('[WorkflowSocketProvider] Execution started (event):', data.executionId);
+                break;
+            case 'execution:completed': {
+                const executionId = data.executionId;
+                console.log('[WorkflowSocketProvider] Execution completed:', executionId);
+                if (!executionId)
+                    return;
+                const execution = this.activeExecutions.get(executionId);
+                if (!execution || execution.completed)
+                    return;
+                execution.completed = true;
+                let finalResponse = '';
+                if ((_c = this.config) === null || _c === void 0 ? void 0 : _c.extractResponse) {
+                    finalResponse = this.config.extractResponse(data);
+                }
+                else if (execution.messages.length > 0) {
+                    finalResponse = execution.messages.join('\n\n');
+                }
+                else if (data.outputData) {
+                    try {
+                        const out = typeof data.outputData === 'string' ? JSON.parse(data.outputData) : data.outputData;
+                        finalResponse = out.response || out.message || out.result || JSON.stringify(out);
+                    }
+                    catch (_f) {
+                        finalResponse = data.outputData;
+                    }
+                }
+                execution.resolve(finalResponse || 'Workflow completed');
+                this.activeExecutions.delete(executionId);
+                break;
+            }
+            case 'execution:failed': {
+                const executionId = data.executionId;
+                const errorMessage = data.errorMessage || data.error || 'Workflow execution failed';
+                console.error('[WorkflowSocketProvider] Execution failed:', executionId, errorMessage);
+                if (!executionId)
+                    return;
+                const execution = this.activeExecutions.get(executionId);
+                if (!execution || execution.completed)
+                    return;
+                execution.completed = true;
+                execution.reject(new Error(errorMessage));
+                this.activeExecutions.delete(executionId);
+                break;
+            }
+            case 'execution:node-started':
+                console.log('[WorkflowSocketProvider] Node started:', data.nodeName);
+                if (data.nodeName)
+                    (_d = this.onNodeStarted) === null || _d === void 0 ? void 0 : _d.call(this, data.nodeName);
+                break;
+            case 'execution:node-completed':
+                console.log('[WorkflowSocketProvider] Node completed:', data.nodeName);
+                if (data.nodeName)
+                    (_e = this.onNodeCompleted) === null || _e === void 0 ? void 0 : _e.call(this, data.nodeName);
+                break;
+        }
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.socket) {
+                // Unsubscribe from workflow
+                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workflowId) {
+                    this.socket.emit('nk:unsubscribe:workflow', { workflowId: this.config.workflowId });
+                }
+                this.socket.disconnect();
+                this.socket = null;
+            }
+            this.connected = false;
+            this.activeExecutions.clear();
+            console.log('[WorkflowSocketProvider] Disconnected');
+        });
+    }
+    isConnected() {
+        var _a;
+        return this.connected && ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) === true;
+    }
+    sendMessage(text, context) {
+        return __asyncGenerator(this, arguments, function* sendMessage_1() {
+            var _a, _b;
+            if (!this.connected || !this.socket || !this.config) {
+                yield yield __await(this.formatError('Not Connected', 'Socket is not connected. Please check your connection.'));
+                return yield __await(void 0);
+            }
+            try {
+                // Build input payload
+                const input = this.buildInput(text, context);
+                // Trigger workflow via HTTP
+                const triggerUrl = this.config.triggerEndpoint.replace('{workflowId}', this.config.workflowId);
+                const fullUrl = `${this.config.socketUrl}${triggerUrl}`;
+                console.log('[WorkflowSocketProvider] Triggering workflow:', fullUrl, input);
+                const response = yield __await(fetch(fullUrl, {
+                    method: 'POST',
+                    headers: Object.assign({ 'Content-Type': 'application/json' }, this.config.headers),
+                    body: JSON.stringify(input)
+                }));
+                if (!response.ok) {
+                    const errorText = yield __await(response.text().catch(() => response.statusText));
+                    yield yield __await(this.formatError(`${response.status} ${response.statusText}`, errorText));
+                    return yield __await(void 0);
+                }
+                // Get execution ID from response header or body
+                const executionId = response.headers.get('X-Execution-Id') ||
+                    ((_a = (yield __await(response.json().catch(() => ({}))))) === null || _a === void 0 ? void 0 : _a.executionId);
+                if (!executionId) {
+                    yield yield __await(this.formatError('Execution Error', 'No execution ID received from server'));
+                    return yield __await(void 0);
+                }
+                console.log('[WorkflowSocketProvider] Execution started:', executionId);
+                // Notify listener about execution start
+                if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.onExecutionStart) {
+                    this.config.onExecutionStart(executionId, this.config.workflowId);
+                }
+                // Subscribe to this specific execution
+                this.subscribeToExecution(executionId);
+                // Create a promise that will resolve when execution completes
+                const resultPromise = new Promise((resolve, reject) => {
+                    this.activeExecutions.set(executionId, {
+                        messages: [],
+                        resolve,
+                        reject,
+                        completed: false
+                    });
+                    // Timeout
+                    setTimeout(() => {
+                        const execution = this.activeExecutions.get(executionId);
+                        if (execution && !execution.completed) {
+                            execution.completed = true;
+                            // If we have messages, return them instead of timeout error
+                            if (execution.messages.length > 0) {
+                                resolve(execution.messages.join('\n\n'));
+                            }
+                            else {
+                                reject(new Error('Execution timeout'));
+                            }
+                            this.activeExecutions.delete(executionId);
+                        }
+                    }, this.config.responseTimeout);
+                });
+                // Stream messages as they come in
+                const execution = this.activeExecutions.get(executionId);
+                let lastYieldedCount = 0;
+                // Poll for new messages while waiting for completion
+                const pollInterval = setInterval(() => {
+                    if (execution.messages.length > lastYieldedCount) {
+                        // New messages available - will be yielded in the loop below
+                        lastYieldedCount = execution.messages.length;
+                    }
+                }, 100);
+                try {
+                    // Yield messages as they arrive
+                    while (!execution.completed) {
+                        if (execution.messages.length > 0) {
+                            // Yield all accumulated messages so far
+                            const currentMessages = execution.messages.join('\n\n');
+                            yield yield __await(currentMessages);
+                        }
+                        // Small delay to prevent tight loop
+                        yield __await(new Promise(resolve => setTimeout(resolve, 200)));
+                    }
+                    clearInterval(pollInterval);
+                    // Wait for final result
+                    const finalResult = yield __await(resultPromise);
+                    yield yield __await(finalResult);
+                }
+                catch (error) {
+                    clearInterval(pollInterval);
+                    throw error;
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                yield yield __await(this.formatError('Workflow Error', errorMessage));
+                this.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    buildInput(text, context) {
+        var _a, _b, _c;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.buildInput) {
+            return this.config.buildInput(text, context);
+        }
+        // Debug: log context to see if files are being passed
+        console.log('[WorkflowSocketProvider] buildInput context.uploadedFiles:', context.uploadedFiles);
+        // Use thread ID if available, otherwise fall back to session ID for context memory
+        const threadId = ((_b = context.currentThread) === null || _b === void 0 ? void 0 : _b.id) || this.sessionId;
+        // Default input structure for chat workflows
+        const input = {
+            message: text,
+            threadId,
+            modules: context.selectedModules,
+            metadata: context.metadata,
+            files: ((_c = context.uploadedFiles) === null || _c === void 0 ? void 0 : _c.map(f => {
+                var _a;
+                return ({
+                    id: f.id,
+                    name: f.name,
+                    type: f.type,
+                    mimeType: f.mimeType,
+                    url: f.url,
+                    base64: (_a = f.metadata) === null || _a === void 0 ? void 0 : _a.base64 // Include base64 for backend processing (OCR, etc.)
+                });
+            })) || []
+        };
+        console.log('[WorkflowSocketProvider] buildInput threadId:', threadId, 'files count:', input.files.length);
+        return input;
+    }
+    /**
+     * Change the workflow ID (useful for switching between workflows)
+     */
+    setWorkflowId(workflowId) {
+        if (this.config) {
+            // Unsubscribe from old workflow
+            if (this.socket && this.config.workflowId) {
+                this.socket.emit('nk:unsubscribe:workflow', { workflowId: this.config.workflowId });
+            }
+            this.config.workflowId = workflowId;
+            // Subscribe to new workflow
+            if (this.socket && this.connected) {
+                this.subscribeToWorkflow(workflowId);
+            }
+        }
+    }
+    /**
+     * Get the underlying socket instance
+     */
+    getSocket() {
+        return this.socket;
+    }
+    /**
+     * Upload file - for workflow provider, files are sent with the message payload
+     * Converts file to base64 for backend processing (e.g., OCR)
+     */
+    uploadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Generate a local ID for the file
+            const id = `file-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+            // Create a local blob URL for preview purposes
+            const previewUrl = URL.createObjectURL(file);
+            // Convert file to base64 for backend processing
+            const base64 = yield this.fileToBase64(file);
+            // Determine file type from mime type
+            const mimeType = file.type || 'application/octet-stream';
+            const fileType = this.determineFileType(mimeType);
+            console.log(`[WorkflowSocketProvider] File prepared: ${file.name} (${file.size} bytes)`);
+            return {
+                id,
+                name: file.name,
+                size: file.size,
+                type: fileType,
+                mimeType,
+                url: previewUrl, // For UI preview
+                previewUrl: fileType === ChatbotFileType.Image ? previewUrl : undefined,
+                uploadProgress: 100,
+                metadata: {
+                    provider: 'workflow-socket',
+                    uploadedAt: new Date().toISOString(),
+                    base64, // Include base64 data for backend processing
+                },
+            };
+        });
+    }
+    /**
+     * Convert a File to base64 string
+     */
+    fileToBase64(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                const result = reader.result;
+                // Remove data URL prefix (e.g., "data:image/png;base64,")
+                const base64 = result.split(',')[1] || result;
+                resolve(base64);
+            };
+            reader.onerror = reject;
+            reader.readAsDataURL(file);
+        });
+    }
+    /**
+     * Determine ChatbotFileType from mime type
+     */
+    determineFileType(mimeType) {
+        if (mimeType.startsWith('image/'))
+            return ChatbotFileType.Image;
+        if (mimeType.startsWith('video/'))
+            return ChatbotFileType.Video;
+        if (mimeType.startsWith('audio/'))
+            return ChatbotFileType.Audio;
+        if (mimeType.startsWith('application/pdf') ||
+            mimeType.includes('document') ||
+            mimeType.startsWith('text/'))
+            return ChatbotFileType.Document;
+        if (mimeType.includes('zip') ||
+            mimeType.includes('rar') ||
+            mimeType.includes('tar'))
+            return ChatbotFileType.Archive;
+        if (mimeType.includes('javascript') ||
+            mimeType.includes('json') ||
+            mimeType.includes('xml'))
+            return ChatbotFileType.Code;
+        return ChatbotFileType.Unknown;
+    }
+    formatError(title, description) {
+        return `[ERROR_START][ERROR_TITLE_START]${title}[ERROR_TITLE_END]${description}[ERROR_END]`;
+    }
+    onError(error) {
+        console.error('[WorkflowSocketProvider] Error:', error);
+    }
+}
+//# sourceMappingURL=workflow-socket-provider.js.map

package/dist/src/components/chatbot/storage/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export { MemoryStorage, LocalStorageAdapter, IndexedDBStorage } from './storage-implementations.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/chatbot/storage/index.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+// Storage implementations
+export { MemoryStorage, LocalStorageAdapter, IndexedDBStorage } from './storage-implementations.js';
+//# sourceMappingURL=index.js.map

package/dist/src/components/chatbot/storage/storage-implementations.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import type { ChatbotStorage } from '../core/types.js';
+/**
+ * In-memory storage (data lost on page refresh)
+ */
+export declare class MemoryStorage implements ChatbotStorage {
+    private store;
+    save(key: string, data: any): Promise<void>;
+    load(key: string): Promise<any>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+/**
+ * LocalStorage-based storage (persists across page refreshes)
+ */
+export declare class LocalStorageAdapter implements ChatbotStorage {
+    save(key: string, data: any): Promise<void>;
+    load(key: string): Promise<any>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+/**
+ * IndexedDB storage (for larger data, better performance)
+ */
+export declare class IndexedDBStorage implements ChatbotStorage {
+    private dbName;
+    private storeName;
+    private db?;
+    constructor(dbName?: string, storeName?: string);
+    private getDB;
+    save(key: string, data: any): Promise<void>;
+    load(key: string): Promise<any>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+//# sourceMappingURL=storage-implementations.d.ts.map