@nuraly/lumenui 0.1.0 → 0.2.2

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

@@ -0,0 +1,390 @@
+/**
+ * @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';
+/**
+ * Default event names
+ */
+const DEFAULT_EVENTS = {
+    send: 'message:send',
+    response: 'message:response',
+    stream: 'message:stream',
+    error: 'message:error',
+    typingStart: 'typing:start',
+    typingEnd: 'typing:end',
+    toolCall: 'tool:call',
+    toolCallEnd: 'tool:end'
+};
+/**
+ * Generic Socket.io provider for real-time chatbot communication
+ *
+ * Works with any socket.io backend - workflows, custom AI servers, etc.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const provider = new SocketProvider();
+ * await provider.connect({
+ *   url: 'http://localhost:8000',
+ *   path: '/socket.io/chat',
+ *   events: {
+ *     send: 'chat:message',
+ *     response: 'chat:response',
+ *     stream: 'chat:stream'
+ *   }
+ * });
+ * ```
+ *
+ * @example With custom payload builder
+ * ```typescript
+ * const provider = new SocketProvider();
+ * await provider.connect({
+ *   url: 'http://localhost:8000',
+ *   events: { send: 'ask', response: 'answer' },
+ *   buildPayload: (text, context) => ({
+ *     question: text,
+ *     threadId: context.currentThread?.id,
+ *     modules: context.selectedModules
+ *   })
+ * });
+ * ```
+ *
+ * @example Workflow backend
+ * ```typescript
+ * const provider = new SocketProvider();
+ * await provider.connect({
+ *   url: 'http://localhost:8000',
+ *   path: '/socket.io/workflow',
+ *   events: {
+ *     send: 'workflow:trigger',
+ *     response: 'execution:completed',
+ *     stream: 'execution:node-completed',
+ *     error: 'execution:failed'
+ *   },
+ *   buildPayload: (text, context) => ({
+ *     workflowId: context.metadata.workflowId,
+ *     input: { message: text }
+ *   })
+ * });
+ * ```
+ */
+export class SocketProvider {
+    constructor() {
+        this.id = 'socket';
+        this.name = 'Socket.io Provider';
+        this.capabilities = {
+            streaming: true,
+            fileUpload: false,
+            modules: false,
+            functions: false
+        };
+        this.socket = null;
+        this.config = null;
+        this.connected = false;
+        this.responseResolvers = new Map();
+    }
+    connect(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!config.url) {
+                throw new Error('Socket URL is required');
+            }
+            this.config = Object.assign(Object.assign({}, config), { events: Object.assign(Object.assign({}, DEFAULT_EVENTS), config.events), autoReconnect: (_a = config.autoReconnect) !== null && _a !== void 0 ? _a : true, reconnectionAttempts: (_b = config.reconnectionAttempts) !== null && _b !== void 0 ? _b : 5, responseTimeout: (_c = config.responseTimeout) !== null && _c !== void 0 ? _c : 30000 });
+            const socketUrl = config.namespace
+                ? `${config.url}${config.namespace}`
+                : config.url;
+            this.socket = io(socketUrl, {
+                path: config.path || '/socket.io',
+                transports: ['websocket', 'polling'],
+                autoConnect: true,
+                reconnection: this.config.autoReconnect,
+                reconnectionAttempts: this.config.reconnectionAttempts,
+                extraHeaders: config.headers
+            });
+            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('[SocketProvider] Connected:', this.socket.id);
+                    resolve();
+                });
+                this.socket.on('connect_error', (error) => {
+                    clearTimeout(timeout);
+                    console.error('[SocketProvider] Connection error:', error);
+                    reject(error);
+                });
+                this.socket.on('disconnect', (reason) => {
+                    this.connected = false;
+                    console.log('[SocketProvider] Disconnected:', reason);
+                });
+                // Setup event listeners
+                this.setupEventListeners();
+            });
+        });
+    }
+    setupEventListeners() {
+        if (!this.socket || !this.config)
+            return;
+        const events = this.config.events;
+        // Response event (complete message)
+        this.socket.on(events.response, (data) => {
+            console.log('[SocketProvider] Response received:', data);
+            const messageId = this.extractMessageId(data);
+            const resolver = this.responseResolvers.get(messageId) ||
+                this.getLatestResolver();
+            if (resolver) {
+                const message = this.extractMessage(data);
+                resolver.resolve(message);
+                this.responseResolvers.delete(messageId);
+            }
+        });
+        // Stream event (chunks)
+        if (events.stream) {
+            this.socket.on(events.stream, (data) => {
+                console.log('[SocketProvider] Stream chunk:', data);
+                const messageId = this.extractMessageId(data);
+                const resolver = this.responseResolvers.get(messageId) ||
+                    this.getLatestResolver();
+                if (resolver) {
+                    resolver.isStreaming = true;
+                    const chunk = this.extractMessage(data);
+                    resolver.chunks.push(chunk);
+                }
+            });
+        }
+        // Error event
+        if (events.error) {
+            this.socket.on(events.error, (data) => {
+                console.error('[SocketProvider] Error event:', 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);
+                }
+            });
+        }
+        // Tool/function call events
+        if (events.toolCall) {
+            this.socket.on(events.toolCall, (data) => {
+                var _a;
+                const toolName = data.name || data.toolName || data.function || 'unknown';
+                (_a = this.onToolCall) === null || _a === void 0 ? void 0 : _a.call(this, toolName);
+            });
+        }
+        if (events.toolCallEnd) {
+            this.socket.on(events.toolCallEnd, () => {
+                var _a;
+                (_a = this.onToolCallEnd) === null || _a === void 0 ? void 0 : _a.call(this);
+            });
+        }
+    }
+    getLatestResolver() {
+        // Get the most recent resolver if no messageId match
+        const keys = Array.from(this.responseResolvers.keys());
+        if (keys.length > 0) {
+            return this.responseResolvers.get(keys[keys.length - 1]);
+        }
+        return null;
+    }
+    extractMessageId(data) {
+        return data.messageId || data.id || data.executionId || 'default';
+    }
+    extractMessage(data) {
+        var _a, _b, _c;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.extractMessage) {
+            return this.config.extractMessage(data);
+        }
+        // Try common response formats
+        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);
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket) {
+                this.socket.disconnect();
+                this.socket = null;
+            }
+            this.connected = false;
+            this.responseResolvers.clear();
+            console.log('[SocketProvider] 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() {
+            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);
+            }
+            const messageId = `msg_${Date.now()}_${crypto.randomUUID().slice(0, 9)}`;
+            const payload = this.buildPayload(text, context, messageId);
+            try {
+                // Create a promise that will be resolved when we get a response
+                const responsePromise = new Promise((resolve, reject) => {
+                    this.responseResolvers.set(messageId, {
+                        resolve,
+                        reject,
+                        chunks: [],
+                        isStreaming: false
+                    });
+                    // Set timeout
+                    setTimeout(() => {
+                        const resolver = this.responseResolvers.get(messageId);
+                        if (resolver) {
+                            // If we have chunks, resolve with them
+                            if (resolver.chunks.length > 0) {
+                                resolve(resolver.chunks.join(''));
+                            }
+                            else {
+                                reject(new Error('Response timeout'));
+                            }
+                            this.responseResolvers.delete(messageId);
+                        }
+                    }, this.config.responseTimeout);
+                });
+                // Emit the message
+                console.log('[SocketProvider] Sending message:', this.config.events.send, payload);
+                this.socket.emit(this.config.events.send, payload);
+                // If streaming is enabled, yield chunks as they come
+                if (this.config.events.stream) {
+                    const resolver = this.responseResolvers.get(messageId);
+                    let lastYieldedLength = 0;
+                    // Poll for chunks while waiting for response
+                    const checkInterval = setInterval(() => {
+                        if (resolver && resolver.chunks.length > lastYieldedLength) {
+                            // Don't yield here - we'll yield after the interval
+                            lastYieldedLength = resolver.chunks.length;
+                        }
+                    }, 50);
+                    // Wait for the response
+                    try {
+                        const response = yield __await(responsePromise);
+                        clearInterval(checkInterval);
+                        yield yield __await(response);
+                    }
+                    catch (error) {
+                        clearInterval(checkInterval);
+                        throw error;
+                    }
+                }
+                else {
+                    // Non-streaming: just wait for complete response
+                    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('Socket Error', errorMessage));
+                this.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    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 });
+        }
+        // Default payload structure
+        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
+            }))
+        };
+    }
+    /**
+     * Emit a custom event on the socket
+     */
+    emit(event, data) {
+        if (this.socket && this.connected) {
+            this.socket.emit(event, data);
+        }
+    }
+    /**
+     * Subscribe to a custom event
+     */
+    on(event, callback) {
+        if (this.socket) {
+            this.socket.on(event, callback);
+        }
+    }
+    /**
+     * Unsubscribe from a custom event
+     */
+    off(event, callback) {
+        if (this.socket) {
+            this.socket.off(event, callback);
+        }
+    }
+    /**
+     * Get the underlying socket instance for advanced usage
+     */
+    getSocket() {
+        return this.socket;
+    }
+    /**
+     * Format error messages with title and description
+     */
+    formatError(title, description) {
+        return `[ERROR_START][ERROR_TITLE_START]${title}[ERROR_TITLE_END]${description}[ERROR_END]`;
+    }
+    onError(error) {
+        console.error('[SocketProvider] Error:', error);
+    }
+}
+//# sourceMappingURL=socket-provider.js.map

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

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { Socket } from 'socket.io-client';
+import type { ChatbotProvider, ProviderCapabilities, ProviderConfig, ChatbotContext } from '../core/types.js';
+import type { ChatbotFile } from '../chatbot.types.js';
+/**
+ * Workflow socket provider configuration
+ */
+export interface WorkflowSocketProviderConfig extends ProviderConfig {
+    /** Socket.io server URL (default: window.location.origin) */
+    socketUrl?: string;
+    /** Socket.io path (default: /socket.io/workflow) */
+    socketPath?: string;
+    /** Workflow ID to trigger */
+    workflowId: string;
+    /** HTTP trigger endpoint template (default: /api/v1/workflows/{workflowId}/trigger/chat) */
+    triggerEndpoint?: string;
+    /** Custom headers for HTTP trigger */
+    headers?: Record<string, string>;
+    /** Response timeout in ms (default: 60000) */
+    responseTimeout?: number;
+    /** Build custom input payload */
+    buildInput?: (text: string, context: ChatbotContext) => any;
+    /** Extract final response from execution completed data */
+    extractResponse?: (data: any) => string;
+    /** Callback when execution starts with executionId */
+    onExecutionStart?: (executionId: string, workflowId: string) => void;
+    /** Callback when a chat message is received (for real-time display, including retries) */
+    onMessage?: (message: string) => void;
+}
+/**
+ * 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 declare class WorkflowSocketProvider implements ChatbotProvider {
+    readonly id = "workflow-socket";
+    readonly name = "Workflow Socket Provider";
+    readonly capabilities: ProviderCapabilities;
+    protected socket: Socket | null;
+    protected config: WorkflowSocketProviderConfig | null;
+    protected connected: boolean;
+    /** Called when a workflow node starts executing */
+    onNodeStarted?: (nodeName: string) => void;
+    /** Called when a workflow node completes */
+    onNodeCompleted?: (nodeName: string) => void;
+    protected readonly sessionId: string;
+    protected activeExecutions: Map<string, {
+        messages: string[];
+        resolve: (value: string) => void;
+        reject: (error: Error) => void;
+        completed: boolean;
+    }>;
+    connect(config: WorkflowSocketProviderConfig): Promise<void>;
+    protected subscribeToWorkflow(workflowId: string): void;
+    protected subscribeToExecution(executionId: string): void;
+    protected setupEventListeners(): void;
+    protected _handleEvent(event: string, data: any): void;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    sendMessage(text: string, context: ChatbotContext): AsyncIterator<string>;
+    protected buildInput(text: string, context: ChatbotContext): any;
+    /**
+     * Change the workflow ID (useful for switching between workflows)
+     */
+    setWorkflowId(workflowId: string): void;
+    /**
+     * Get the underlying socket instance
+     */
+    getSocket(): Socket | null;
+    /**
+     * Upload file - for workflow provider, files are sent with the message payload
+     * Converts file to base64 for backend processing (e.g., OCR)
+     */
+    uploadFile(file: File): Promise<ChatbotFile>;
+    /**
+     * Convert a File to base64 string
+     */
+    private fileToBase64;
+    /**
+     * Determine ChatbotFileType from mime type
+     */
+    private determineFileType;
+    protected formatError(title: string, description: string): string;
+    onError(error: Error): void;
+}
+//# sourceMappingURL=workflow-socket-provider.d.ts.map