@nuraly/lumenui 0.2.1 → 0.2.2

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

@@ -0,0 +1,246 @@
+/**
+ * @license
+ * Copyright 2023 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]); }
+};
+/**
+ * OpenAI provider for ChatGPT integration
+ */
+export class OpenAIProvider {
+    constructor() {
+        this.id = 'openai';
+        this.name = 'OpenAI';
+        this.capabilities = {
+            streaming: true,
+            fileUpload: true,
+            modules: true,
+            functions: true,
+            imageGeneration: true
+        };
+        this.apiKey = '';
+        this.apiUrl = 'https://api.openai.com/v1';
+        this.model = 'gpt-4';
+        this.temperature = 0.7;
+        this.connected = false;
+    }
+    connect(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!config.apiKey) {
+                throw new Error('OpenAI API key is required');
+            }
+            this.apiKey = config.apiKey;
+            this.apiUrl = config.apiUrl || this.apiUrl;
+            this.model = config.model || this.model;
+            this.temperature = (_a = config.temperature) !== null && _a !== void 0 ? _a : this.temperature;
+            this.maxTokens = config.maxTokens;
+            // Verify connection
+            try {
+                const response = yield fetch(`${this.apiUrl}/models`, {
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`
+                    }
+                });
+                if (!response.ok) {
+                    throw new Error(`OpenAI connection failed: ${response.statusText}`);
+                }
+                this.connected = true;
+                console.log('[OpenAIProvider] Connected successfully');
+            }
+            catch (error) {
+                this.connected = false;
+                throw error;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
+            console.log('[OpenAIProvider] Disconnected');
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    sendMessage(text, context) {
+        return __asyncGenerator(this, arguments, function* sendMessage_1() {
+            var _a, _b, _c;
+            if (!this.connected) {
+                throw new Error('Provider not connected');
+            }
+            const messages = this.buildMessages(text, context);
+            const response = yield __await(fetch(`${this.apiUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages,
+                    temperature: this.temperature,
+                    max_tokens: this.maxTokens,
+                    stream: true
+                })
+            }));
+            if (!response.ok) {
+                throw new Error(`OpenAI API error: ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is null');
+            }
+            // Process Server-Sent Events stream
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = yield __await(reader.read());
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.trim() === '')
+                            continue;
+                        if (line.trim() === 'data: [DONE]')
+                            continue;
+                        if (line.startsWith('data: ')) {
+                            const data = line.slice(6);
+                            try {
+                                const parsed = JSON.parse(data);
+                                const content = (_c = (_b = (_a = parsed.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.delta) === null || _c === void 0 ? void 0 : _c.content;
+                                if (content) {
+                                    yield yield __await(content);
+                                }
+                            }
+                            catch (e) {
+                                console.error('Error parsing SSE data:', e);
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        });
+    }
+    getAvailableModules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Return example modules - in real implementation, fetch from OpenAI
+            return [
+                {
+                    id: 'web-search',
+                    name: 'Web Search',
+                    description: 'Search the web for information',
+                    icon: 'search',
+                    enabled: true
+                },
+                {
+                    id: 'code-interpreter',
+                    name: 'Code Interpreter',
+                    description: 'Execute Python code',
+                    icon: 'code',
+                    enabled: true
+                },
+                {
+                    id: 'dalle',
+                    name: 'DALL-E',
+                    description: 'Generate images',
+                    icon: 'image',
+                    enabled: true
+                }
+            ];
+        });
+    }
+    callModule(moduleId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Implementation for function/tool calling
+            console.log(`[OpenAIProvider] Calling module: ${moduleId}`, params);
+            return { success: true, result: 'Module executed' };
+        });
+    }
+    uploadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Upload file to OpenAI
+            const formData = new FormData();
+            formData.append('file', file);
+            formData.append('purpose', 'assistants');
+            const response = yield fetch(`${this.apiUrl}/files`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: formData
+            });
+            if (!response.ok) {
+                throw new Error(`File upload failed: ${response.statusText}`);
+            }
+            const data = yield response.json();
+            return {
+                id: data.id,
+                name: file.name,
+                size: file.size,
+                type: this.determineFileType(file.type),
+                mimeType: file.type,
+                url: data.url
+            };
+        });
+    }
+    onError(error) {
+        console.error('[OpenAIProvider] Error:', error);
+    }
+    buildMessages(text, context) {
+        const messages = [];
+        // Add context messages (last N messages for context)
+        const contextMessages = context.messages.slice(-10); // Last 10 messages
+        for (const msg of contextMessages) {
+            messages.push({
+                role: msg.sender === 'user' ? 'user' : 'assistant',
+                content: msg.text
+            });
+        }
+        // Add current message if not already included
+        if (!messages.find(m => m.role === 'user' && m.content === text)) {
+            messages.push({
+                role: 'user',
+                content: text
+            });
+        }
+        return messages;
+    }
+    determineFileType(mimeType) {
+        if (mimeType.startsWith('image/'))
+            return 'image';
+        if (mimeType.startsWith('video/'))
+            return 'video';
+        if (mimeType.startsWith('audio/'))
+            return 'audio';
+        return 'document';
+    }
+}
+//# sourceMappingURL=openai-provider.js.map

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

@@ -0,0 +1,159 @@
+/**
+ * @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';
+/**
+ * Socket.io event configuration
+ */
+export interface SocketEventConfig {
+    /** Event name to emit when sending a message */
+    send: string;
+    /** Event name for complete response */
+    response: string;
+    /** Event name for streaming chunks (optional) */
+    stream?: string;
+    /** Event name for errors */
+    error?: string;
+    /** Event name for typing indicator start */
+    typingStart?: string;
+    /** Event name for typing indicator end */
+    typingEnd?: string;
+    /** Event name for tool/function call start */
+    toolCall?: string;
+    /** Event name for tool/function call end */
+    toolCallEnd?: string;
+}
+/**
+ * Socket provider configuration
+ */
+export interface SocketProviderConfig extends ProviderConfig {
+    /** Socket.io server URL */
+    url: string;
+    /** Socket.io path (default: /socket.io) */
+    path?: string;
+    /** Socket.io namespace (optional) */
+    namespace?: string;
+    /** Event names configuration */
+    events: SocketEventConfig;
+    /** Custom headers for socket handshake */
+    headers?: Record<string, string>;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnection attempts (default: 5) */
+    reconnectionAttempts?: number;
+    /** Build custom payload from message and context */
+    buildPayload?: (text: string, context: ChatbotContext) => any;
+    /** Extract message from response data */
+    extractMessage?: (data: any) => string;
+    /** Response timeout in ms (default: 30000) */
+    responseTimeout?: number;
+}
+/**
+ * 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 declare class SocketProvider implements ChatbotProvider {
+    readonly id = "socket";
+    readonly name = "Socket.io Provider";
+    readonly capabilities: ProviderCapabilities;
+    protected socket: Socket | null;
+    protected config: SocketProviderConfig | null;
+    protected connected: boolean;
+    /** Called when a tool/function call is detected */
+    onToolCall?: (name: string) => void;
+    /** Called when a tool/function call ends */
+    onToolCallEnd?: () => void;
+    protected responseResolvers: Map<string, {
+        resolve: (value: string) => void;
+        reject: (error: Error) => void;
+        chunks: string[];
+        isStreaming: boolean;
+    }>;
+    connect(config: SocketProviderConfig): Promise<void>;
+    protected setupEventListeners(): void;
+    protected getLatestResolver(): {
+        resolve: (value: string) => void;
+        reject: (error: Error) => void;
+        chunks: string[];
+        isStreaming: boolean;
+    } | null | undefined;
+    protected extractMessageId(data: any): string;
+    protected extractMessage(data: any): string;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    sendMessage(text: string, context: ChatbotContext): AsyncIterator<string>;
+    protected buildPayload(text: string, context: ChatbotContext, messageId: string): any;
+    /**
+     * Emit a custom event on the socket
+     */
+    emit(event: string, data?: any): void;
+    /**
+     * Subscribe to a custom event
+     */
+    on(event: string, callback: (data: any) => void): void;
+    /**
+     * Unsubscribe from a custom event
+     */
+    off(event: string, callback?: (data: any) => void): void;
+    /**
+     * Get the underlying socket instance for advanced usage
+     */
+    getSocket(): Socket | null;
+    /**
+     * Format error messages with title and description
+     */
+    protected formatError(title: string, description: string): string;
+    onError(error: Error): void;
+}
+//# sourceMappingURL=socket-provider.d.ts.map