@nuraly/lumenui 0.2.1 → 0.2.2

package/dist/src/components/chatbot/core/chatbot-core.controller.js

@@ -0,0 +1,824 @@
+/**
+ * @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());
+    });
+};
+import { EventBus } from './event-bus.js';
+import { ValidationError } from './types.js';
+import { ChatbotSender, ChatbotMessageState } from '../chatbot.types.js';
+// Handlers (domain operations)
+import { StateHandler, MessageHandler, ThreadHandler, FileHandler, ModuleHandler, SuggestionHandler } from './handlers/index.js';
+// Services (infrastructure)
+import { ProviderService, ValidationService, StorageService, PluginService } from './services/index.js';
+/**
+ * Pure chatbot core controller - completely UI-agnostic
+ * All UI interactions happen through injected callbacks
+ * Can be extended and overridden for custom behavior
+ */
+export class ChatbotCoreController {
+    constructor(config = {}) {
+        this.plugins = new Map();
+        this.config = config;
+        this.ui = config.ui || {};
+        this.eventBus = new EventBus();
+        this.pluginService = new PluginService();
+        this.plugins = this.pluginService.getPluginsMap();
+        // Register plugins BEFORE initializing state so initial messages can be processed
+        if (config.plugins) {
+            config.plugins.forEach(plugin => this.pluginService.registerPlugin(plugin, this));
+        }
+        const initialState = this.initializeState(config);
+        this.stateHandler = new StateHandler(initialState, this.eventBus, this.ui, this.plugins, this.config);
+        this.messageHandler = new MessageHandler(this.stateHandler, this.eventBus, this.plugins);
+        this.threadHandler = new ThreadHandler(this.stateHandler, this.eventBus, this.ui, this.config, config.provider);
+        this.fileHandler = new FileHandler(this.stateHandler, this.eventBus);
+        this.moduleHandler = new ModuleHandler(this.stateHandler, this.eventBus);
+        this.suggestionHandler = new SuggestionHandler(this.stateHandler);
+        this.providerService = new ProviderService(config.provider, this.stateHandler, this.messageHandler, this.fileHandler, this.eventBus, this.ui, this.plugins);
+        this.validationService = new ValidationService(this.config);
+        this.storageService = new StorageService(config.storage, this.stateHandler, this.config);
+        if (config.provider) {
+            const provider = config.provider;
+            queueMicrotask(() => { void this.initializeProvider(provider); });
+        }
+        this.setupLifecycleHooks();
+    }
+    initializeProvider(provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!provider.isConnected()) {
+                    yield provider.connect({});
+                }
+                yield this.autoLoadConversations(provider);
+            }
+            catch (error) {
+                this.logError('Failed to connect provider:', error);
+            }
+        });
+    }
+    // ===== LIFECYCLE HOOKS (Override Points) =====
+    /**
+     * Initialize state - override to customize initial state
+     */
+    initializeState(config) {
+        // Process initial messages through plugins to render tags
+        const processedMessages = config.initialMessages
+            ? config.initialMessages.map(msg => this.processMessageThroughPlugins(msg))
+            : [];
+        return {
+            messages: processedMessages,
+            threads: config.initialThreads || [],
+            modules: config.enableModules ? [] : undefined,
+            selectedModules: [],
+            uploadedFiles: [],
+            suggestions: config.initialSuggestions || [],
+            isTyping: false,
+            isProcessing: false,
+            currentThreadId: undefined,
+            metadata: config.metadata || {}
+        };
+    }
+    /**
+     * Process a message text through all registered plugins to render HTML tags
+     */
+    processMessageThroughPlugins(message) {
+        if (!message.text || typeof message.text !== 'string') {
+            return message;
+        }
+        // Get all tag-aware plugins
+        const tagAwarePlugins = Array.from(this.plugins.values()).filter(plugin => Array.isArray(plugin.htmlTags) && plugin.htmlTags.length > 0);
+        if (tagAwarePlugins.length === 0) {
+            return message;
+        }
+        let processedText = message.text;
+        let hasHtmlContent = false;
+        // Process each plugin's tags
+        for (const plugin of tagAwarePlugins) {
+            const tags = plugin.htmlTags;
+            for (const tag of tags) {
+                const openTag = tag.open;
+                const closeTag = tag.close;
+                // Find all instances of this tag in the text
+                let searchPos = 0;
+                while (true) {
+                    const openIdx = processedText.indexOf(openTag, searchPos);
+                    if (openIdx === -1)
+                        break;
+                    const contentStart = openIdx + openTag.length;
+                    const closeIdx = processedText.indexOf(closeTag, contentStart);
+                    if (closeIdx === -1) {
+                        // Tag not closed, skip
+                        searchPos = contentStart;
+                        continue;
+                    }
+                    // Extract content between tags
+                    const content = processedText.substring(contentStart, closeIdx);
+                    // Render the HTML block
+                    let html = '';
+                    if (typeof plugin.renderHtmlBlock === 'function') {
+                        try {
+                            html = plugin.renderHtmlBlock(tag.name, content);
+                        }
+                        catch (error) {
+                            console.error(`[ChatbotCore] Error rendering HTML block for plugin ${plugin.id}:`, error);
+                        }
+                    }
+                    if (html) {
+                        // Replace the tag and content with rendered HTML
+                        processedText =
+                            processedText.substring(0, openIdx) +
+                                html +
+                                processedText.substring(closeIdx + closeTag.length);
+                        hasHtmlContent = true;
+                        // Continue searching from after the replacement
+                        searchPos = openIdx + html.length;
+                    }
+                    else {
+                        // No HTML rendered, continue searching after this tag
+                        searchPos = closeIdx + closeTag.length;
+                    }
+                }
+            }
+        }
+        // Return updated message with processed text and metadata flag
+        if (hasHtmlContent) {
+            return Object.assign(Object.assign({}, message), { text: processedText, metadata: Object.assign(Object.assign({}, message.metadata), { renderAsHtml: true }) });
+        }
+        return message;
+    }
+    /**
+     * Run onMessageReceived hooks on all bot messages currently in state.
+     * This ensures plugins like ArtifactPlugin can post-process restored
+     * or externally-loaded messages (not just streamed/added ones).
+     */
+    processRestoredMessagesForPlugins() {
+        const state = this.stateHandler.getState();
+        if (!state.messages || state.messages.length === 0)
+            return;
+        for (const msg of state.messages) {
+            if (msg.sender === 'bot') {
+                this.plugins.forEach(plugin => {
+                    if (plugin.onMessageReceived) {
+                        try {
+                            plugin.onMessageReceived(msg);
+                        }
+                        catch (_a) {
+                            // best-effort
+                        }
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * Setup lifecycle hooks - override to add custom setup logic
+     */
+    setupLifecycleHooks() {
+        this.onBeforeInit();
+        this.onReady().catch(error => {
+            this.logError('Error during initialization:', error);
+        });
+    }
+    /**
+     * Called before initialization - override for custom pre-init logic
+     */
+    onBeforeInit() {
+        this.log('Initializing chatbot controller...');
+    }
+    /**
+     * Called when controller is ready - override for custom initialization
+     */
+    onReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log('Chatbot controller ready');
+            try {
+                const state = this.stateHandler.getState();
+                const firstMsg = state.messages && state.messages.length > 0 ? state.messages[0] : undefined;
+                if (firstMsg && firstMsg.sender === 'bot' && firstMsg.introduction && Array.isArray(firstMsg.suggestions) && firstMsg.suggestions.length > 0) {
+                    this.suggestionHandler.setSuggestions(firstMsg.suggestions);
+                }
+            }
+            catch (e) {
+                this.logError('Error initializing suggestions from initial messages:', e);
+            }
+            // Run onMessageReceived on initial/restored bot messages so plugins
+            // like ArtifactPlugin can post-process them (extract code fences, etc.)
+            this.processRestoredMessagesForPlugins();
+            if (this.ui.onStateChange) {
+                this.ui.onStateChange(this.getState());
+            }
+            this.emit('ready', this.stateHandler.getState());
+        });
+    }
+    /**
+     * Called when controller is destroyed - override for cleanup
+     */
+    onDestroy() {
+        this.log('Destroying chatbot controller...');
+        this.storageService.stopAutoSave();
+        this.pluginService.clearPlugins();
+        this.eventBus.removeAllListeners();
+    }
+    // ===== STATE MANAGEMENT =====
+    updateState(updates) {
+        this.stateHandler.updateState(updates);
+    }
+    // ===== MESSAGE OPERATIONS =====
+    /**
+     * Send a message (main public API)
+     */
+    sendMessage(text_1) {
+        return __awaiter(this, arguments, void 0, function* (text, options = {}) {
+            this.log('Sending message:', text);
+            try {
+                const state = this.stateHandler.getState();
+                if (this.config.enableThreads && !state.currentThreadId) {
+                    yield this.threadHandler.createThread('New Chat');
+                }
+                const processedText = yield this.beforeMessageSent(text, options);
+                if (!options.skipValidation) {
+                    const validation = yield this.validationService.validateMessage(processedText);
+                    if (!validation.isValid) {
+                        const error = new ValidationError(validation.errors);
+                        this.handleValidationError(error);
+                        throw error;
+                    }
+                }
+                const message = this.messageHandler.createUserMessage(processedText, options.metadata);
+                if (options.files) {
+                    message.files = options.files;
+                }
+                this.messageHandler.addMessage(message);
+                const currentState = this.stateHandler.getState();
+                if (options.threadId || currentState.currentThreadId) {
+                    this.threadHandler.updateThreadMessages(options.threadId || currentState.currentThreadId);
+                }
+                yield this.afterMessageSent(message);
+                this.providerService.processMessage(message).catch(error => {
+                    this.logError('Error processing with provider:', error);
+                });
+                return message;
+            }
+            catch (error) {
+                this.handleError(error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Stop the current provider processing/stream
+     */
+    stop() {
+        this.providerService.stopCurrentProcessing();
+    }
+    /**
+     * Add a message programmatically
+     */
+    addMessage(data) {
+        const message = this.messageHandler.createMessage(data);
+        // Process message through plugins if it's from the bot and has text content
+        const processedMessage = message.sender === 'bot'
+            ? this.processMessageThroughPlugins(message)
+            : message;
+        this.messageHandler.addMessage(processedMessage);
+        return processedMessage;
+    }
+    /**
+     * Update an existing message by ID
+     */
+    updateMessage(id, updates) {
+        this.messageHandler.updateMessage(id, updates);
+    }
+    /**
+     * Delete a message by ID
+     */
+    deleteMessage(id) {
+        this.messageHandler.deleteMessage(id);
+    }
+    /**
+     * Clear all messages from the current conversation
+     */
+    clearMessages() {
+        this.updateState({ messages: [] });
+    }
+    /**
+     * Get all messages in the current conversation
+     */
+    getMessages() {
+        return this.stateHandler.getState().messages;
+    }
+    // ===== FILE OPERATIONS =====
+    /**
+     * Upload files to the chatbot
+     * @param files - Optional array of files to upload. If not provided, will trigger file dialog
+     * @returns Array of uploaded ChatbotFile objects
+     */
+    uploadFiles(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config.enableFileUpload) {
+                throw new Error('File upload is not enabled');
+            }
+            let filesToUpload = files;
+            if (!filesToUpload && this.ui.openFileDialog) {
+                filesToUpload = yield this.ui.openFileDialog();
+            }
+            if (!filesToUpload || filesToUpload.length === 0) {
+                return [];
+            }
+            const uploadedFiles = [];
+            for (const file of filesToUpload) {
+                try {
+                    const validation = yield this.validationService.validateFile(file, {
+                        maxFileSize: this.config.maxFileSize,
+                        allowedTypes: this.config.allowedFileTypes
+                    });
+                    if (!validation.isValid) {
+                        if (this.ui.showNotification) {
+                            this.ui.showNotification(validation.errors[0] || 'File validation failed', 'error');
+                        }
+                        continue;
+                    }
+                    const chatbotFile = yield this.fileHandler.createChatbotFile(file);
+                    const uploaded = yield this.providerService.uploadFileToProvider(file);
+                    if (uploaded) {
+                        Object.assign(chatbotFile, uploaded);
+                    }
+                    uploadedFiles.push(chatbotFile);
+                    this.fileHandler.addFile(chatbotFile);
+                    if (this.ui.showFilePreview) {
+                        this.ui.showFilePreview(chatbotFile);
+                    }
+                }
+                catch (error) {
+                    this.logError('Error uploading file:', error);
+                    if (this.ui.showNotification) {
+                        this.ui.showNotification(`Failed to upload ${file.name}`, 'error');
+                    }
+                }
+            }
+            return uploadedFiles;
+        });
+    }
+    /**
+     * Remove an uploaded file by ID
+     */
+    removeFile(fileId) {
+        this.fileHandler.removeFile(fileId);
+    }
+    /**
+     * Clear all uploaded files
+     */
+    clearFiles() {
+        this.fileHandler.clearFiles();
+    }
+    /**
+     * Get all uploaded files
+     */
+    getUploadedFiles() {
+        return this.stateHandler.getState().uploadedFiles;
+    }
+    // ===== THREAD OPERATIONS =====
+    /**
+     * Create a new conversation thread
+     */
+    createThread(title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.threadHandler.createThread(title);
+        });
+    }
+    /**
+     * Switch to a different thread
+     */
+    switchThread(threadId) {
+        this.threadHandler.switchThread(threadId);
+        this.processRestoredMessagesForPlugins();
+    }
+    /**
+     * Delete a thread by ID
+     */
+    deleteThread(threadId) {
+        this.threadHandler.deleteThread(threadId);
+    }
+    /**
+     * Rename a thread
+     */
+    renameThread(threadId, newTitle) {
+        this.threadHandler.renameThread(threadId, newTitle);
+    }
+    /**
+     * Toggle bookmark on a thread
+     */
+    bookmarkThread(threadId) {
+        this.threadHandler.bookmarkThread(threadId);
+    }
+    /**
+     * Get the currently active thread
+     */
+    getCurrentThread() {
+        const state = this.stateHandler.getState();
+        return state.threads.find(t => t.id === state.currentThreadId);
+    }
+    /**
+     * Get all available threads
+     */
+    getThreads() {
+        return this.stateHandler.getState().threads;
+    }
+    // ===== MODULE OPERATIONS =====
+    /**
+     * Set available modules for the chatbot
+     */
+    setModules(modules) {
+        this.moduleHandler.setModules(modules);
+    }
+    /**
+     * Select specific modules by their IDs
+     */
+    selectModules(moduleIds) {
+        this.moduleHandler.selectModules(moduleIds);
+    }
+    /**
+     * Toggle a module's selection state
+     */
+    toggleModule(moduleId) {
+        this.moduleHandler.toggleModule(moduleId);
+    }
+    /**
+     * Get currently selected modules
+     */
+    getSelectedModules() {
+        return this.moduleHandler.getSelectedModules();
+    }
+    // ===== SUGGESTION OPERATIONS =====
+    /**
+     * Set suggestion chips for user interaction
+     */
+    setSuggestions(suggestions) {
+        this.suggestionHandler.setSuggestions(suggestions);
+    }
+    /**
+     * Clear all suggestions
+     */
+    clearSuggestions() {
+        this.suggestionHandler.clearSuggestions();
+    }
+    // ===== HOOKS (Override Points) =====
+    /**
+     * Called before sending message - override to transform or validate
+     */
+    beforeMessageSent(text, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let processedText = text;
+            for (const plugin of this.plugins.values()) {
+                if (plugin.beforeSend) {
+                    processedText = yield plugin.beforeSend(processedText);
+                }
+            }
+            return processedText;
+        });
+    }
+    /**
+     * Called after message is sent - override for custom logic
+     */
+    afterMessageSent(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log('Message sent:', message);
+        });
+    }
+    /**
+     * Called before provider call - override for custom logic
+     */
+    beforeProviderCall(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log('Calling provider for message:', message.id);
+        });
+    }
+    /**
+     * Called after provider call - override for custom logic
+     */
+    afterProviderCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log('Provider call completed');
+        });
+    }
+    /**
+     * Handle provider error - override to customize error handling
+     */
+    handleProviderError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logError('Provider error:', error);
+            const errorMessage = this.messageHandler.createMessage({
+                sender: ChatbotSender.Bot,
+                text: 'Sorry, there was an error processing your request.',
+                state: ChatbotMessageState.Error,
+                timestamp: new Date().toISOString()
+            });
+            this.messageHandler.addMessage(errorMessage);
+            if (this.ui.showNotification) {
+                this.ui.showNotification('Failed to process message', 'error');
+            }
+            this.emit('provider:error', error);
+            yield this.pluginService.executeHook('onError', error);
+        });
+    }
+    /**
+     * Handle validation error - override to customize
+     */
+    handleValidationError(error) {
+        this.logError('Validation error:', error);
+        if (this.ui.showNotification) {
+            this.ui.showNotification(error.errors[0], 'error');
+        }
+        this.emit('validation:error', error);
+    }
+    /**
+     * Handle general error - override to customize
+     */
+    handleError(error) {
+        this.logError('Error:', error);
+        this.emit('error', error);
+        this.plugins.forEach(plugin => {
+            if (plugin.onError) {
+                plugin.onError(error);
+            }
+        });
+    }
+    // ===== PLUGIN SYSTEM =====
+    /**
+     * Register a new plugin with the chatbot
+     */
+    registerPlugin(plugin) {
+        this.pluginService.registerPlugin(plugin, this);
+    }
+    /**
+     * Unregister a plugin by ID
+     */
+    unregisterPlugin(pluginId) {
+        this.pluginService.unregisterPlugin(pluginId);
+    }
+    /**
+     * Get a registered plugin by ID
+     */
+    getPlugin(pluginId) {
+        return this.pluginService.getPlugin(pluginId);
+    }
+    // ===== PROVIDER MANAGEMENT =====
+    /**
+     * Set the AI provider for the chatbot
+     */
+    setProvider(provider) {
+        this.providerService.setProvider(provider);
+        // Only connect if not already connected
+        if (!provider.isConnected()) {
+            provider.connect({}).then(() => __awaiter(this, void 0, void 0, function* () {
+                // Auto-load conversations if provider supports it
+                yield this.autoLoadConversations(provider);
+                this.emit('provider:connected', provider.id);
+            })).catch(error => {
+                this.logError('Failed to connect provider:', error);
+            });
+        }
+        else {
+            // Provider already connected, just auto-load conversations and emit event
+            this.autoLoadConversations(provider).catch(error => {
+                this.logError('Failed to auto-load conversations:', error);
+            });
+            this.emit('provider:connected', provider.id);
+        }
+    }
+    // ===== STORAGE MANAGEMENT =====
+    /**
+     * Set the storage adapter for persisting chatbot state
+     */
+    setStorage(storage) {
+        this.storageService.setStorage(storage);
+    }
+    /**
+     * Save current state to storage
+     */
+    saveToStorage() {
+        return __awaiter(this, arguments, void 0, function* (key = 'chatbot-state') {
+            yield this.storageService.saveState(key);
+        });
+    }
+    /**
+     * Load state from storage
+     */
+    loadFromStorage() {
+        return __awaiter(this, arguments, void 0, function* (key = 'chatbot-state') {
+            yield this.storageService.loadState(key);
+            // Process loaded messages through plugins to render any HTML tags
+            const state = this.stateHandler.getState();
+            if (state.messages && state.messages.length > 0) {
+                const processedMessages = state.messages.map(msg => this.processMessageThroughPlugins(msg));
+                this.stateHandler.updateState({ messages: processedMessages });
+                // Run onMessageReceived so plugins like ArtifactPlugin can post-process
+                this.processRestoredMessagesForPlugins();
+            }
+        });
+    }
+    // ===== EVENT BUS =====
+    /**
+     * Subscribe to an event
+     * @returns Unsubscribe function
+     */
+    on(event, handler) {
+        return this.eventBus.on(event, handler);
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, data) {
+        this.eventBus.emit(event, data);
+    }
+    // ===== PUBLIC API =====
+    /**
+     * Get current chatbot state (readonly)
+     */
+    getState() {
+        return this.stateHandler.getState();
+    }
+    /**
+     * Update chatbot state (use with caution)
+     */
+    setState(updates) {
+        // If messages are being set, process them through plugins first
+        if (updates.messages && Array.isArray(updates.messages)) {
+            updates.messages = updates.messages.map(msg => this.processMessageThroughPlugins(msg));
+        }
+        // If threads are being set, process their messages through plugins
+        if (updates.threads && Array.isArray(updates.threads)) {
+            updates.threads = updates.threads.map(thread => (Object.assign(Object.assign({}, thread), { messages: thread.messages.map(msg => this.processMessageThroughPlugins(msg)) })));
+        }
+        this.updateState(updates);
+        // Run onMessageReceived so plugins like ArtifactPlugin can post-process
+        if (updates.messages) {
+            this.processRestoredMessagesForPlugins();
+        }
+    }
+    /**
+     * Load conversations from external source (API, database, etc.)
+     * This is a helper method that processes messages through plugins
+     */
+    loadConversations(threads) {
+        const processedThreads = threads.map(thread => (Object.assign(Object.assign({}, thread), { messages: thread.messages.map(msg => this.processMessageThroughPlugins(msg)) })));
+        this.updateState({
+            threads: processedThreads,
+            currentThreadId: processedThreads.length > 0 ? processedThreads[0].id : undefined,
+            messages: processedThreads.length > 0 ? processedThreads[0].messages : []
+        });
+        // Run onMessageReceived so plugins like ArtifactPlugin can post-process
+        this.processRestoredMessagesForPlugins();
+    }
+    /**
+     * Auto-load conversations from provider if it has loadConversations method
+     * This is called automatically when provider connects
+     */
+    autoLoadConversations(provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!provider)
+                return;
+            // Check if provider has loadConversations method
+            if (typeof provider.loadConversations === 'function') {
+                try {
+                    this.log('Auto-loading conversations from provider...');
+                    const conversations = yield provider.loadConversations();
+                    if (Array.isArray(conversations) && conversations.length > 0) {
+                        this.log(`Loaded ${conversations.length} conversation summaries`);
+                        // Load full conversation details if loadConversation method exists
+                        const loadedThreads = [];
+                        if (typeof provider.loadConversation === 'function') {
+                            for (const conv of conversations) {
+                                try {
+                                    const fullConversation = yield provider.loadConversation(conv.id);
+                                    if (fullConversation) {
+                                        const thread = {
+                                            id: fullConversation.id,
+                                            title: fullConversation.title,
+                                            messages: fullConversation.messages || [],
+                                            createdAt: fullConversation.createdAt,
+                                            updatedAt: fullConversation.updatedAt
+                                        };
+                                        loadedThreads.push(thread);
+                                    }
+                                }
+                                catch (error) {
+                                    this.logError(`Failed to load conversation ${conv.id}:`, error);
+                                }
+                            }
+                        }
+                        else {
+                            // If no loadConversation method, convert summary to threads
+                            for (const conv of conversations) {
+                                const thread = {
+                                    id: conv.id,
+                                    title: conv.title,
+                                    messages: [],
+                                    createdAt: conv.createdAt,
+                                    updatedAt: conv.updatedAt
+                                };
+                                loadedThreads.push(thread);
+                            }
+                        }
+                        if (loadedThreads.length > 0) {
+                            this.log(`Successfully loaded ${loadedThreads.length} conversations`);
+                            this.loadConversations(loadedThreads);
+                        }
+                    }
+                    else {
+                        this.log('No conversations to load from provider');
+                    }
+                }
+                catch (error) {
+                    this.logError('Failed to auto-load conversations from provider:', error);
+                }
+            }
+        });
+    }
+    /**
+     * Set or update UI callback functions
+     */
+    setUICallbacks(callbacks) {
+        this.ui = Object.assign(Object.assign({}, this.ui), callbacks);
+    }
+    /**
+     * Get chatbot configuration (readonly)
+     */
+    getConfig() {
+        return Object.freeze(Object.assign({}, this.config));
+    }
+    /**
+     * Update chatbot configuration
+     * Merges the provided partial config with existing config
+     */
+    updateConfig(partialConfig) {
+        this.config = Object.assign(Object.assign({}, this.config), partialConfig);
+    }
+    /**
+     * Set typing indicator state
+     */
+    setTyping(isTyping) {
+        this.updateState({ isTyping });
+        this.emit(isTyping ? 'typing:start' : 'typing:end');
+    }
+    /**
+     * Set dynamic status text shown beside the loading indicator
+     */
+    setStatusText(text) {
+        this.updateState({ statusText: text });
+    }
+    /**
+     * Clear the dynamic status text
+     */
+    clearStatusText() {
+        this.updateState({ statusText: undefined });
+    }
+    /**
+     * Get context for provider calls
+     */
+    getContext() {
+        const state = this.stateHandler.getState();
+        return {
+            messages: state.messages,
+            currentThread: this.getCurrentThread(),
+            selectedModules: state.selectedModules,
+            metadata: state.metadata,
+            uploadedFiles: state.uploadedFiles
+        };
+    }
+    /**
+     * Destroy the chatbot controller and clean up resources
+     */
+    destroy() {
+        this.onDestroy();
+    }
+    // ===== UTILITIES =====
+    generateId(prefix) {
+        return `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    formatFileSize(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(2)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[ChatbotCore]', ...args);
+        }
+    }
+    logError(...args) {
+        console.error('[ChatbotCore]', ...args);
+    }
+}
+//# sourceMappingURL=chatbot-core.controller.js.map