kimi-js/kimi-script.js

import KimiDatabase from "./kimi-database.js";
import KimiLLMManager from "./kimi-llm-manager.js";
import KimiEmotionSystem from "./kimi-emotion-system.js";
import KimiMemorySystem from "./kimi-memory-system.js";
import KimiMemory from "./kimi-memory.js";

document.addEventListener("DOMContentLoaded", async function () {
    const DEFAULT_SYSTEM_PROMPT = window.DEFAULT_SYSTEM_PROMPT;

    let kimiDB = null;
    let kimiLLM = null;
    let isSystemReady = false;

    // Global debug flag for sync/log verbosity (default: false)
    if (typeof window.KIMI_DEBUG_SYNC === "undefined") {
        window.KIMI_DEBUG_SYNC = false;
    }

    const kimiInit = new KimiInitManager();
    let kimiVideo = null;

    // Error manager is already initialized in kimi-error-manager.js

    try {
        kimiDB = new KimiDatabase();
        await kimiDB.init();

        // Expose globally as soon as available
        window.kimiDB = kimiDB;

        const selectedCharacter = await kimiDB.getPreference("selectedCharacter", "kimi");
        const favorabilityLabel = window.KimiDOMUtils.get("#favorability-label");
        if (favorabilityLabel && window.KIMI_CHARACTERS && window.KIMI_CHARACTERS[selectedCharacter]) {
            favorabilityLabel.setAttribute("data-i18n", "affection_level_of");
            favorabilityLabel.setAttribute(
                "data-i18n-params",
                JSON.stringify({ name: window.KIMI_CHARACTERS[selectedCharacter].name })
            );
            favorabilityLabel.textContent = `💖 Affection level of ${window.KIMI_CHARACTERS[selectedCharacter].name}`;
        }
        const chatHeaderName = window.KimiDOMUtils.get(".chat-header span[data-i18n]");
        if (chatHeaderName && window.KIMI_CHARACTERS && window.KIMI_CHARACTERS[selectedCharacter]) {
            chatHeaderName.setAttribute("data-i18n", `chat_with_${selectedCharacter}`);
        }
        kimiLLM = new KimiLLMManager(kimiDB);
        window.kimiLLM = kimiLLM;
        await kimiLLM.init();

        // Initialize unified emotion system
        window.kimiEmotionSystem = new KimiEmotionSystem(kimiDB);

        // Initialize the new memory system
        window.kimiMemorySystem = new KimiMemorySystem(kimiDB);
        await window.kimiMemorySystem.init();

        // Initialize legacy memory for favorability
        const kimiMemory = new KimiMemory(kimiDB);
        await kimiMemory.init();
        window.kimiMemory = kimiMemory;

        // Expose globally (already set before init)

        // Load available models now that LLM is ready
        if (window.loadAvailableModels) {
            setTimeout(() => window.loadAvailableModels(), 500);
        }

        isSystemReady = true;
        window.isSystemReady = true;
        // API config UI will be initialized after ApiUi is defined
        if (window.refreshAllSliders) {
            try {
                await window.refreshAllSliders();
            } catch {}
        }
    } catch (error) {
        console.error("Initialization error:", error);
    }
    // Centralized helpers for API config UI
    const ApiUi = {
        presenceDot: () => document.getElementById("api-key-presence"),
        presenceDotTest: () => document.getElementById("api-key-presence-test"),
        apiKeyInput: () => document.getElementById("provider-api-key"),
        toggleBtn: () => document.getElementById("toggle-api-key"),
        providerSelect: () => document.getElementById("llm-provider"),
        baseUrlInput: () => document.getElementById("llm-base-url"),
        modelIdInput: () => document.getElementById("llm-model-id"),
        savedBadge: () => document.getElementById("api-key-saved"),
        statusSpan: () => document.getElementById("api-status"),
        testBtn: () => document.getElementById("test-api"),
        // Saved key indicator (left dot)
        setPresence(color) {
            const dot = this.presenceDot();
            if (dot) dot.style.backgroundColor = color;
        },
        // Test result indicator (right dot)
        setTestPresence(color) {
            const dot2 = this.presenceDotTest();
            if (dot2) dot2.style.backgroundColor = color;
        },
        clearStatus() {
            const s = this.statusSpan();
            if (s) {
                s.textContent = "";
                s.style.color = "";
            }
        },
        setTestEnabled(enabled) {
            const b = this.testBtn();
            if (b) b.disabled = !enabled;
        }
    };

    // Initial presence state based on current input value
    {
        const currentVal = (ApiUi.apiKeyInput() || {}).value || "";
        const colorInit = currentVal && currentVal.length > 0 ? "#4caf50" : "#9e9e9e";
        ApiUi.setPresence(colorInit);
        // On load, test status is unknown
        ApiUi.setTestPresence("#9e9e9e");
    }

    // Initialize API config UI from saved preferences
    async function initializeApiConfigUI() {
        try {
            if (!window.kimiDB) return;
            const provider = await window.kimiDB.getPreference("llmProvider", "openrouter");
            const baseUrl = await window.kimiDB.getPreference(
                "llmBaseUrl",
                provider === "openrouter"
                    ? "https://openrouter.ai/api/v1/chat/completions"
                    : "https://api.openai.com/v1/chat/completions"
            );
            const modelId = await window.kimiDB.getPreference(
                "llmModelId",
                window.kimiLLM ? window.kimiLLM.currentModel : "model-id"
            );
            const providerSelect = ApiUi.providerSelect();
            if (providerSelect) providerSelect.value = provider;
            const baseUrlInput = ApiUi.baseUrlInput();
            const modelIdInput = ApiUi.modelIdInput();
            const apiKeyInput = ApiUi.apiKeyInput();

            // Set base URL based on modifiability
            if (baseUrlInput) {
                const isModifiable = isUrlModifiable(provider);
                baseUrlInput.value = baseUrl || "";
                baseUrlInput.disabled = !isModifiable;
                baseUrlInput.style.opacity = isModifiable ? "1" : "0.6";
            }
            // Only prefill model for OpenRouter, others should show placeholder only
            if (modelIdInput) {
                if (provider === "openrouter") {
                    if (!modelIdInput.value) modelIdInput.value = modelId;
                } else {
                    modelIdInput.value = "";
                }
            }
            // Load the provider-specific key
            const keyPref = window.KimiProviderUtils
                ? window.KimiProviderUtils.getKeyPrefForProvider(provider)
                : "providerApiKey";
            const storedKey = await window.kimiDB.getPreference(keyPref, "");
            if (apiKeyInput) apiKeyInput.value = storedKey || "";
            ApiUi.setPresence(storedKey ? "#4caf50" : "#9e9e9e");
            ApiUi.setTestPresence("#9e9e9e");
            const savedBadge = ApiUi.savedBadge();
            if (savedBadge) {
                // Show only if provider requires a key and key exists
                if (provider !== "ollama" && storedKey) {
                    savedBadge.style.display = "inline";
                } else {
                    savedBadge.style.display = "none";
                }
            }
            ApiUi.clearStatus();
            // Enable/disable Test button according to validation (Ollama does not require API key)
            const valid = !!(window.KIMI_VALIDATORS && window.KIMI_VALIDATORS.validateApiKey(storedKey || ""));
            ApiUi.setTestEnabled(provider === "ollama" ? true : valid);
            // Update dynamic label and placeholders using change handler logic
            if (providerSelect && typeof providerSelect.dispatchEvent === "function") {
                const ev = new Event("change");
                providerSelect.dispatchEvent(ev);
            }
        } catch (e) {
            console.warn("Failed to initialize API config UI:", e);
        }
    }
    // Hydrate API config UI from DB after ApiUi is defined and function declared
    initializeApiConfigUI();

    // Listen for model changes and update the UI only for OpenRouter
    window.addEventListener("llmModelChanged", function (event) {
        const modelIdInput = ApiUi.modelIdInput();
        const providerSelect = ApiUi.providerSelect();

        // Only update the field if current provider is OpenRouter
        if (modelIdInput && event.detail && event.detail.id && providerSelect && providerSelect.value === "openrouter") {
            modelIdInput.value = event.detail.id;
        }
    });

    // Helper function to check if URL is modifiable for current provider
    function isUrlModifiable(provider) {
        return provider === "openai-compatible" || provider === "ollama";
    }

    const providerSelectEl = document.getElementById("llm-provider");
    if (providerSelectEl) {
        providerSelectEl.addEventListener("change", async function (e) {
            const provider = e.target.value;
            const baseUrlInput = ApiUi.baseUrlInput();
            const modelIdInput = ApiUi.modelIdInput();
            const apiKeyInput = ApiUi.apiKeyInput();

            const placeholders = {
                openrouter: {
                    url: "https://openrouter.ai/api/v1/chat/completions",
                    keyPh: "sk-or-v1-...",
                    model: window.kimiLLM ? window.kimiLLM.currentModel : "model-id"
                },
                openai: {
                    url: "https://api.openai.com/v1/chat/completions",
                    keyPh: "sk-...",
                    model: "gpt-4o-mini"
                },
                groq: {
                    url: "https://api.groq.com/openai/v1/chat/completions",
                    keyPh: "gsk_...",
                    model: "llama-3.1-8b-instant"
                },
                together: {
                    url: "https://api.together.xyz/v1/chat/completions",
                    keyPh: "together_...",
                    model: "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
                },
                deepseek: {
                    url: "https://api.deepseek.com/chat/completions",
                    keyPh: "sk-...",
                    model: "deepseek-chat"
                },
                "openai-compatible": {
                    url: "https://your-endpoint/v1/chat/completions",
                    keyPh: "your-key",
                    model: "model-id"
                },
                ollama: {
                    url: "http://localhost:11434/api/chat",
                    keyPh: "",
                    model: "llama3"
                }
            };
            const p = placeholders[provider] || placeholders.openai;
            if (baseUrlInput) {
                baseUrlInput.placeholder = p.url;
                // Only allow URL modification for custom and ollama providers
                const isModifiable = isUrlModifiable(provider);

                if (isModifiable) {
                    // For custom and ollama: load saved URL or use default
                    const savedUrl = await window.kimiDB.getPreference("llmBaseUrl", p.url);
                    baseUrlInput.value = savedUrl;
                    baseUrlInput.disabled = false;
                    baseUrlInput.style.opacity = "1";
                } else {
                    // For other providers: fixed URL, not modifiable
                    baseUrlInput.value = p.url;
                    baseUrlInput.disabled = true;
                    baseUrlInput.style.opacity = "0.6";
                }
            }
            if (apiKeyInput) {
                apiKeyInput.placeholder = p.keyPh;
                // Masquer/désactiver le champ pour Ollama/local
                if (provider === "ollama") {
                    apiKeyInput.value = "";
                    apiKeyInput.disabled = true;
                    apiKeyInput.style.display = "none";
                } else {
                    apiKeyInput.disabled = false;
                    apiKeyInput.style.display = "";
                }
            }
            if (modelIdInput) {
                modelIdInput.placeholder = p.model;
                // Only populate the field for OpenRouter since those are the models we have in the list
                // For other providers, user must manually enter the provider-specific model ID
                modelIdInput.value = provider === "openrouter" && window.kimiLLM ? window.kimiLLM.currentModel : "";
            }
            if (window.kimiDB) {
                await window.kimiDB.setPreference("llmProvider", provider);

                const apiKeyLabel = document.getElementById("api-key-label");
                // Load provider-specific key into the input for clarity
                const keyPref = window.KimiProviderUtils
                    ? window.KimiProviderUtils.getKeyPrefForProvider(provider)
                    : "providerApiKey";
                const storedKey = await window.kimiDB.getPreference(keyPref, "");
                if (apiKeyInput && provider !== "ollama") apiKeyInput.value = storedKey || "";
                const color = provider === "ollama" ? "#9e9e9e" : storedKey && storedKey.length > 0 ? "#4caf50" : "#9e9e9e";
                ApiUi.setPresence(color);
                // Changing provider invalidates previous test state
                ApiUi.setTestPresence("#9e9e9e");
                ApiUi.setTestEnabled(
                    provider === "ollama"
                        ? true
                        : !!(window.KIMI_VALIDATORS && window.KIMI_VALIDATORS.validateApiKey(storedKey || ""))
                );

                // Dynamic label per provider
                if (apiKeyLabel) {
                    apiKeyLabel.textContent = window.KimiProviderUtils
                        ? window.KimiProviderUtils.getLabelForProvider(provider)
                        : "API Key";
                }
                const savedBadge = ApiUi.savedBadge();
                if (savedBadge) {
                    if (provider !== "ollama" && storedKey) {
                        savedBadge.style.display = "inline";
                    } else {
                        savedBadge.style.display = "none";
                    }
                }
                ApiUi.clearStatus();

                // Save URL after all UI updates are complete
                const isModifiable = isUrlModifiable(provider);
                if (isModifiable && baseUrlInput) {
                    await window.kimiDB.setPreference("llmBaseUrl", baseUrlInput.value);
                } else {
                    // For fixed providers, save the standard URL
                    await window.kimiDB.setPreference("llmBaseUrl", p.url);
                }
            }
        });

        // Listen for model ID changes and update the current model
        const modelIdInput = ApiUi.modelIdInput();
        if (modelIdInput) {
            modelIdInput.addEventListener("blur", async function (e) {
                const newModelId = e.target.value.trim();
                if (newModelId && window.kimiLLM && newModelId !== window.kimiLLM.currentModel) {
                    try {
                        await window.kimiLLM.setCurrentModel(newModelId);
                    } catch (error) {
                        console.warn("Failed to set model:", error.message);
                        // Reset to current model if setting failed
                        e.target.value = window.kimiLLM.currentModel || "";
                    }
                }
            });
        }

        // Listen for Base URL changes and save for modifiable providers
        const baseUrlInput = ApiUi.baseUrlInput();
        if (baseUrlInput) {
            baseUrlInput.addEventListener("blur", async function (e) {
                const providerSelect = ApiUi.providerSelect();
                const provider = providerSelect ? providerSelect.value : "openrouter";
                const isModifiable = isUrlModifiable(provider);

                if (isModifiable && window.kimiDB) {
                    const newUrl = e.target.value.trim();
                    if (newUrl) {
                        try {
                            await window.kimiDB.setPreference("llmBaseUrl", newUrl);
                        } catch (error) {
                            console.warn("Failed to save base URL:", error.message);
                        }
                    }
                }
            });
        }
    }

    // Loading screen management
    const hideLoadingScreen = () => {
        const loadingScreen = document.getElementById("loading-screen");
        if (loadingScreen) {
            loadingScreen.style.opacity = "0";
            setTimeout(() => {
                loadingScreen.style.display = "none";
            }, 500);
        }
    };

    // Hide loading screen when resources are loaded
    if (document.readyState === "complete") {
        setTimeout(hideLoadingScreen, 1000);
    } else {
        window.addEventListener("load", () => {
            setTimeout(hideLoadingScreen, 1000);
        });
    }

    // Use centralized video utilities
    let video1 = window.KimiVideoManager.getVideoElement("#video1");
    let video2 = window.KimiVideoManager.getVideoElement("#video2");
    if (!video1 || !video2) {
        const videoContainer = document.querySelector(".video-container");
        if (videoContainer) {
            video1 = window.KimiVideoManager.createVideoElement("video1", "bg-video active");
            video2 = window.KimiVideoManager.createVideoElement("video2", "bg-video");
            videoContainer.appendChild(video1);
            videoContainer.appendChild(video2);
        }
    }
    let activeVideo = video1;
    let inactiveVideo = video2;
    kimiVideo = new window.KimiVideoManager(video1, video2);
    await kimiVideo.init(kimiDB);
    window.kimiVideo = kimiVideo;

    if (video1 && video2 && kimiDB && kimiDB.getSelectedCharacter) {
        try {
            const selectedCharacter = await kimiDB.getSelectedCharacter();
            if (selectedCharacter && window.KIMI_CHARACTERS) {
                kimiVideo.setCharacter(selectedCharacter);
                const folder = window.KIMI_CHARACTERS[selectedCharacter].videoFolder;
                const neutralVideo = `${folder}neutral/neutral-gentle-breathing.mp4`;
                const video1Source = video1.querySelector("source");
                if (video1Source) {
                    video1Source.setAttribute("src", neutralVideo);
                    video1.load();
                }
            }
            if (kimiVideo && kimiVideo.switchToContext) {
                kimiVideo.switchToContext("neutral");
            }
        } catch (e) {
            console.warn("Error loading initial video:", e);
        }
    }

    async function attachCharacterSection() {
        let saveCharacterBtn = window.KimiDOMUtils.get("#save-character-btn");
        if (saveCharacterBtn) {
            saveCharacterBtn.addEventListener("click", async e => {
                const settingsPanel = window.KimiDOMUtils.get(".settings-panel");
                let scrollTop = settingsPanel ? settingsPanel.scrollTop : null;
                const characterGrid = window.KimiDOMUtils.get("#character-grid");
                const selectedCard = characterGrid ? characterGrid.querySelector(".character-card.selected") : null;
                if (!selectedCard) return;
                const charKey = selectedCard.dataset.character;
                // Removed incorrect usage of the API key saved badge here.
                // Character save should not toggle the API key saved indicator.
                const promptInput = window.KimiDOMUtils.get(`#prompt-${charKey}`);
                const prompt = promptInput ? promptInput.value : "";

                await window.kimiDB.setSelectedCharacter(charKey);
                await window.kimiDB.setSystemPromptForCharacter(charKey, prompt);
                // Ensure memory system uses the correct character
                if (window.kimiMemorySystem) {
                    window.kimiMemorySystem.selectedCharacter = charKey;
                }
                if (window.kimiVideo && window.kimiVideo.setCharacter) {
                    window.kimiVideo.setCharacter(charKey);
                    if (window.kimiVideo.switchToContext) {
                        window.kimiVideo.switchToContext("neutral");
                    }
                }
                if (window.voiceManager && window.voiceManager.updateSelectedCharacter) {
                    await window.voiceManager.updateSelectedCharacter();
                }

                await window.loadCharacterSection();
                if (settingsPanel && scrollTop !== null) {
                    requestAnimationFrame(() => {
                        settingsPanel.scrollTop = scrollTop;
                    });
                }
                // Refresh memory tab after character selection
                if (window.kimiMemoryUI && typeof window.kimiMemoryUI.updateMemoryStats === "function") {
                    await window.kimiMemoryUI.updateMemoryStats();
                }
                saveCharacterBtn.setAttribute("data-i18n", "saved");
                saveCharacterBtn.classList.add("success");
                saveCharacterBtn.disabled = true;

                setTimeout(() => {
                    saveCharacterBtn.setAttribute("data-i18n", "save");
                    saveCharacterBtn.classList.remove("success");
                    saveCharacterBtn.disabled = false;
                }, 1500);
            });
        }
        let settingsButton2 = window.KimiDOMUtils.get("#settings-button");
        if (settingsButton2) {
            settingsButton2.addEventListener("click", window.loadCharacterSection);
        }
    }
    await attachCharacterSection();

    const chatContainer = document.getElementById("chat-container");
    const chatButton = document.getElementById("chat-button");
    const chatToggle = document.getElementById("chat-toggle");
    const chatMessages = document.getElementById("chat-messages");
    const chatInput = document.getElementById("chat-input");
    const sendButton = document.getElementById("send-button");
    const chatDelete = document.getElementById("chat-delete");
    const waitingIndicator = document.getElementById("waiting-indicator");

    if (!chatContainer || !chatButton || !chatMessages) {
        console.error("Critical chat elements missing from DOM");
        return;
    }

    window.kimiOverlayManager = new window.KimiOverlayManager();

    chatButton.addEventListener("click", () => {
        window.kimiOverlayManager.toggle("chat-container");
        if (window.kimiOverlayManager.isOpen("chat-container")) {
            window.loadChatHistory();
        }
    });

    if (chatToggle) {
        chatToggle.addEventListener("click", () => {
            window.kimiOverlayManager.close("chat-container");
        });
    }

    // Setup chat input and send button event listeners
    if (sendButton) {
        sendButton.addEventListener("click", () => {
            if (typeof window.sendMessage === "function") {
                window.sendMessage();
            } else {
                console.error("sendMessage function not available");
            }
        });
        console.log("Send button event listener attached");
    } else {
        console.error("Send button not found");
    }

    if (chatInput) {
        chatInput.addEventListener("keydown", e => {
            if (e.key === "Enter" && !e.shiftKey) {
                e.preventDefault();
                if (typeof window.sendMessage === "function") {
                    window.sendMessage();
                } else {
                    console.error("sendMessage function not available");
                }
            }
        });
        console.log("Chat input event listener attached");
    } else {
        console.error("Chat input not found");
    }

    const settingsOverlay = document.getElementById("settings-overlay");
    const settingsButton = document.getElementById("settings-button");
    const settingsClose = document.getElementById("settings-close");

    const helpOverlay = document.getElementById("help-overlay");
    const helpButton = document.getElementById("help-button");
    const helpClose = document.getElementById("help-close");

    if (!settingsButton || !helpButton) {
        console.error("Critical UI buttons missing from DOM");
        return;
    }

    helpButton.addEventListener("click", () => {
        window.kimiOverlayManager.open("help-overlay");
    });

    if (helpClose) {
        helpClose.addEventListener("click", () => {
            window.kimiOverlayManager.close("help-overlay");
        });
    }

    settingsButton.addEventListener("click", () => {
        window.kimiOverlayManager.open("settings-overlay");

        // Prevent multiple settings loading
        if (!window._settingsLoading) {
            window._settingsLoading = true;
            window.loadSettingsData();

            setTimeout(() => {
                window.updateTabsScrollIndicator();
                if (window.initializeAllSliders) window.initializeAllSliders();
                if (window.syncLLMMaxTokensSlider) window.syncLLMMaxTokensSlider();
                if (window.syncLLMTemperatureSlider) window.syncLLMTemperatureSlider();
                if (window.setupSettingsListeners) window.setupSettingsListeners(window.kimiDB, window.kimiMemory);
                if (window.syncPersonalityTraits) window.syncPersonalityTraits();
                if (window.ensureVideoContextConsistency) window.ensureVideoContextConsistency();

                // Only retry loading models if not already done
                if (window.loadAvailableModels && !loadAvailableModels._loading) {
                    setTimeout(() => window.loadAvailableModels(), 100);
                }

                window._settingsLoading = false;
            }, 200);
        }
    });

    if (settingsClose) {
        settingsClose.addEventListener("click", () => {
            window.kimiOverlayManager.close("settings-overlay");
        });
    }

    // Initialisation unifiée de la gestion des tabs
    window.kimiTabManager = new window.KimiTabManager({
        onTabChange: async tabName => {
            if (tabName === "personality") {
                await window.loadCharacterSection();
            }
        }
    });

    window.kimiUIEventManager = new window.KimiUIEventManager();
    window.kimiUIEventManager.addEvent(window, "resize", window.updateTabsScrollIndicator);

    window.kimiFormManager = new window.KimiFormManager({ db: window.kimiDB, memory: window.kimiMemory });

    const testVoiceButton = document.getElementById("test-voice");
    if (testVoiceButton) {
        testVoiceButton.addEventListener("click", () => {
            if (voiceManager) {
                const rate = parseFloat(document.getElementById("voice-rate").value);
                const pitch = parseFloat(document.getElementById("voice-pitch").value);
                const volume = parseFloat(document.getElementById("voice-volume").value);

                if (window.kimiMemory.preferences) {
                    window.kimiMemory.preferences.voiceRate = rate;
                    window.kimiMemory.preferences.voicePitch = pitch;
                    window.kimiMemory.preferences.voiceVolume = volume;
                }

                const testMessage =
                    window.kimiI18nManager?.t("voice_test_message") ||
                    "Hello my love! Here is my new voice configured with all the settings! Do you like it?";
                voiceManager.speak(testMessage, {
                    rate,
                    pitch,
                    volume
                });
            } else {
                console.warn("Voice manager not initialized");
            }
        });
    }

    const testApiButton = document.getElementById("test-api");
    if (testApiButton) {
        testApiButton.addEventListener("click", async () => {
            const statusSpan = ApiUi.statusSpan();
            const apiKeyInput = ApiUi.apiKeyInput();
            const apiKey = apiKeyInput ? apiKeyInput.value.trim() : "";
            const providerSelect = ApiUi.providerSelect();
            const baseUrlInput = ApiUi.baseUrlInput();
            const modelIdInput = ApiUi.modelIdInput();
            const provider = providerSelect ? providerSelect.value : "openrouter";
            const baseUrl = baseUrlInput ? baseUrlInput.value.trim() : "";
            const modelId = modelIdInput ? modelIdInput.value.trim() : "";

            if (!statusSpan) return;

            if (provider !== "ollama" && !apiKey) {
                statusSpan.textContent = window.kimiI18nManager?.t("api_key_missing") || "API key missing";
                statusSpan.style.color = "#ff6b6b";
                return;
            }

            // Validate API key format before saving/testing
            if (provider !== "ollama") {
                const isValid = (window.KIMI_VALIDATORS && window.KIMI_VALIDATORS.validateApiKey(apiKey)) || false;
                if (!isValid) {
                    statusSpan.textContent =
                        window.kimiI18nManager?.t("api_key_invalid_format") ||
                        "Invalid API key format (must start with sk-or-v1-)";
                    statusSpan.style.color = "#ff6b6b";
                    return;
                }
            }

            if (window.kimiDB) {
                // Save API key under provider-specific preference key (skip for Ollama)
                if (provider !== "ollama") {
                    const keyPref = window.KimiProviderUtils
                        ? window.KimiProviderUtils.getKeyPrefForProvider(provider)
                        : "providerApiKey";
                    await window.kimiDB.setPreference(keyPref, apiKey);
                }
                await window.kimiDB.setPreference("llmProvider", provider);
                if (baseUrl) await window.kimiDB.setPreference("llmBaseUrl", baseUrl);
                if (modelId) await window.kimiDB.setPreference("llmModelId", modelId);
            }
            statusSpan.textContent = "Testing in progress...";
            statusSpan.style.color = "#ffa726";

            try {
                if (window.kimiLLM) {
                    // Test API minimal et centralisé pour tous les providers
                    const result = await window.kimiLLM.testApiKeyMinimal(modelId);
                    if (result.success) {
                        statusSpan.textContent = "Connection successful!";
                        statusSpan.style.color = "#4caf50";
                        // Only show saved badge if an actual non-empty API key is stored and provider requires one
                        const savedBadge = ApiUi.savedBadge();
                        if (savedBadge) {
                            const apiKeyInputEl = ApiUi.apiKeyInput();
                            const hasKey = apiKeyInputEl && apiKeyInputEl.value.trim().length > 0;
                            if (provider !== "ollama" && hasKey) {
                                savedBadge.textContent =
                                    (window.kimiI18nManager && window.kimiI18nManager.t("saved_short")) || "Saved";
                                savedBadge.style.display = "inline";
                            } else {
                                savedBadge.style.display = "none";
                            }
                        }

                        if (result.response) {
                            setTimeout(() => {
                                statusSpan.textContent = `Test response: \"${result.response.substring(0, 50)}...\"`;
                            }, 1000);
                        }
                        // Mark test success explicitly
                        ApiUi.setTestPresence("#4caf50");
                    } else {
                        statusSpan.textContent = `${result.error}`;
                        statusSpan.style.color = "#ff6b6b";
                        ApiUi.setTestPresence("#9e9e9e");
                        if (result.error.includes("similaires disponibles")) {
                            setTimeout(() => {}, 1000);
                        }
                    }
                } else {
                    statusSpan.textContent = "LLM manager not initialized";
                    statusSpan.style.color = "#ff6b6b";
                    ApiUi.setTestPresence("#9e9e9e");
                }
            } catch (error) {
                console.error("Error while testing API:", error);
                statusSpan.textContent = `Error: ${error.message}`;
                statusSpan.style.color = "#ff6b6b";
                ApiUi.setTestPresence("#9e9e9e");

                if (error.message.includes("non disponible")) {
                    setTimeout(() => {}, 1000);
                }
            }
        });
    }

    // Global, single handler for API key input to save and update presence in real-time
    (function setupApiKeyInputHandler() {
        const input = ApiUi.apiKeyInput();
        if (!input) return;
        let t;
        input.addEventListener("input", () => {
            clearTimeout(t);
            t = setTimeout(async () => {
                const providerEl = ApiUi.providerSelect();
                const provider = providerEl ? providerEl.value : "openrouter";
                const keyPref = window.KimiProviderUtils
                    ? window.KimiProviderUtils.getKeyPrefForProvider(provider)
                    : "providerApiKey";
                const value = input.value.trim();
                // Update Test button state immediately
                const validNow = !!(window.KIMI_VALIDATORS && window.KIMI_VALIDATORS.validateApiKey(value));
                ApiUi.setTestEnabled(provider === "ollama" ? true : validNow);
                if (window.kimiDB) {
                    try {
                        await window.kimiDB.setPreference(keyPref, value);
                        const savedBadge = ApiUi.savedBadge();
                        if (savedBadge) {
                            if (value) {
                                savedBadge.textContent =
                                    (window.kimiI18nManager && window.kimiI18nManager.t("saved_short")) || "Saved";
                                savedBadge.style.display = "inline";
                            } else {
                                savedBadge.style.display = "none";
                            }
                        }
                        ApiUi.setPresence(value ? "#4caf50" : "#9e9e9e");
                        // Any key change invalidates previous test state
                        ApiUi.setTestPresence("#9e9e9e");
                        ApiUi.clearStatus();
                    } catch (e) {
                        // Validation error from DB
                        const s = ApiUi.statusSpan();
                        if (s) {
                            s.textContent = e?.message || "Invalid API key";
                            s.style.color = "#ff6b6b";
                        }
                        ApiUi.setTestEnabled(false);
                        ApiUi.setTestPresence("#9e9e9e");
                    }
                }
            }, window.KIMI_SECURITY_CONFIG?.DEBOUNCE_DELAY || 300);
        });
    })();

    // Toggle show/hide for API key
    (function setupToggleEye() {
        const btn = ApiUi.toggleBtn();
        const input = ApiUi.apiKeyInput();
        if (!btn || !input) return;
        btn.addEventListener("click", () => {
            const showing = input.type === "text";
            input.type = showing ? "password" : "text";
            btn.setAttribute("aria-pressed", String(!showing));
            const icon = btn.querySelector("i");
            if (icon) {
                icon.classList.toggle("fa-eye");
                icon.classList.toggle("fa-eye-slash");
            }
            btn.setAttribute("aria-label", showing ? "Show API key" : "Hide API key");
        });
    })();

    kimiInit.register(
        "appearanceManager",
        async () => {
            const manager = new KimiAppearanceManager(window.kimiDB);
            await manager.init();
            window.kimiAppearanceManager = manager;
            return manager;
        },
        [],
        500
    );
    kimiInit.register(
        "dataManager",
        async () => {
            const manager = new KimiDataManager(window.kimiDB);
            await manager.init();
            window.kimiDataManager = manager;
            return manager;
        },
        [],
        600
    );

    kimiInit.register(
        "voiceManager",
        async () => {
            if (window.KimiVoiceManager) {
                const manager = new KimiVoiceManager(window.kimiDB, window.kimiMemory);
                const success = await manager.init();
                if (success) {
                    manager.setOnSpeechAnalysis(window.analyzeAndReact);
                    return manager;
                }
            }
            return null;
        },
        [],
        1000
    );

    try {
        await kimiInit.initializeAll();
        window.voiceManager = kimiInit.getInstance("voiceManager");
        window.kimiMemory.updateFavorabilityBar();
    } catch (error) {
        console.error("Initialization error:", error);
    }

    // Setup unified event handlers to prevent duplicates
    setupUnifiedEventHandlers();

    // Initialize language and UI
    await initializeLanguageAndUI();

    // Setup message handling
    setupMessageHandling();

    // Function definitions
    function setupUnifiedEventHandlers() {
        // SIMPLE FIX: Initialize _kimiEventCleanup to prevent undefined error
        if (!window._kimiEventCleanup) {
            window._kimiEventCleanup = [];
        }

        // Helper function to safely add event listeners
        function safeAddEventListener(element, event, handler, identifier) {
            if (element && !element[identifier]) {
                element.addEventListener(event, handler);
                element[identifier] = true;

                // Simple cleanup system
                const cleanupFn = () => {
                    element.removeEventListener(event, handler);
                    element[identifier] = false;
                };

                // Store cleanup function in the simple array
                window._kimiEventCleanup.push(cleanupFn);
            }
        }

        // Chat event handlers
        const chatDelete = document.getElementById("chat-delete");
        if (chatDelete) {
            const handler = async () => {
                if (confirm("Do you really want to delete all chat messages? This cannot be undone.")) {
                    const chatMessages = document.getElementById("chat-messages");
                    if (chatMessages) {
                        chatMessages.textContent = "";
                    }
                    if (window.kimiDB && window.kimiDB.db) {
                        try {
                            await window.kimiDB.db.conversations.clear();
                        } catch (error) {
                            console.error("Error deleting conversations:", error);
                        }
                    }
                }
            };
            safeAddEventListener(chatDelete, "click", handler, "_kimiChatDeleteHandlerAttached");
        }
    }

    async function initializeLanguageAndUI() {
        // Language initialization
        window.kimiI18nManager = new window.KimiI18nManager();
        const lang = await kimiDB.getPreference("selectedLanguage", "en");
        await window.kimiI18nManager.setLanguage(lang);
        // Note: Language selector event listener is now handled by VoiceManager.setupLanguageSelector()
        // This prevents duplicate event listeners and ensures proper coordination between voice and i18n systems

        window.kimiUIStateManager = new window.KimiUIStateManager();
    }

    function setupMessageHandling() {
        // Chat event handlers are already attached in the main script
        // No need to reattach them here to avoid duplicates
    }

    // ==== BATCHED EVENT AGGREGATOR (personality + preferences) ====
    const batchedUpdates = {
        personality: null,
        preferences: new Set()
    };
    let batchTimer = null;

    function scheduleFlush() {
        if (batchTimer) return;
        batchTimer = setTimeout(flushBatchedUpdates, 100); // 100ms coalescing window
    }

    async function flushBatchedUpdates() {
        const personalityPayload = batchedUpdates.personality;
        const prefKeys = Array.from(batchedUpdates.preferences);
        batchedUpdates.personality = null;
        batchedUpdates.preferences.clear();
        batchTimer = null;

        // Apply personality update once (last-wins)
        if (personalityPayload) {
            const { character, traits } = personalityPayload;
            const defaults = (window.getTraitDefaults && window.getTraitDefaults()) || {
                affection: 55, // Lowered to match emotion system defaults
                romance: 50,
                empathy: 75,
                playfulness: 55,
                humor: 60,
                intelligence: 70
            };

            // Prefer persisted DB traits over defaults to avoid temporary inconsistencies.
            let dbTraits = null;
            try {
                if (window.kimiDB && typeof window.kimiDB.getAllPersonalityTraits === "function") {
                    dbTraits = await window.kimiDB.getAllPersonalityTraits(character || null);
                }
            } catch (e) {
                dbTraits = null;
            }

            const baseline = { ...defaults, ...(dbTraits || {}) };
            const safeTraits = {};
            for (const key of Object.keys(defaults)) {
                // If incoming payload provides the key, use it; otherwise use baseline (DB -> defaults)
                let raw = Object.prototype.hasOwnProperty.call(traits || {}, key) ? traits[key] : baseline[key];
                let v = Number(raw);
                if (!isFinite(v) || isNaN(v)) v = Number(baseline[key]);
                v = Math.max(0, Math.min(100, v));
                safeTraits[key] = v;
            }
            if (window.KIMI_DEBUG_SYNC) {
                console.log(`🧠 (Batched) Personality updated for ${character}:`, safeTraits);
            }
            // Centralize side-effects elsewhere; aggregator remains a coalesced logger only.
        }

        // Preference keys batch (currently UI refresh for sliders already handled elsewhere)
        if (prefKeys.length > 0) {
            // Potential future hook: log or perform aggregated operations
            // console.log("⚙️ Batched preference keys:", prefKeys);
        }
    }

    // Also listen to the DB-wrapped event name to preserve batched logging
    window.addEventListener("personality:updated", event => {
        batchedUpdates.personality = event.detail; // last event wins
        scheduleFlush();
    });
    window.addEventListener("preferenceUpdated", event => {
        if (event.detail?.key) batchedUpdates.preferences.add(event.detail.key);
        scheduleFlush();
    });

    // Add global keyboard event listener for microphone toggle (F8)
    let f8KeyPressed = false;

    document.addEventListener("keydown", function (event) {
        // Check if F8 key is pressed and no input field is focused
        if (event.key === "F8" && !f8KeyPressed) {
            f8KeyPressed = true;
            const activeElement = document.activeElement;
            const isInputFocused =
                activeElement &&
                (activeElement.tagName === "INPUT" || activeElement.tagName === "TEXTAREA" || activeElement.isContentEditable);

            // Only trigger if no input field is focused
            if (!isInputFocused && window.voiceManager && window.voiceManager.toggleMicrophone) {
                event.preventDefault();
                window.voiceManager.toggleMicrophone();
            }
        }
    });

    // Refresh sliders when character or language preference changes
    window.addEventListener("preferenceUpdated", evt => {
        const k = evt.detail?.key;
        if (!k) return;
        if (k === "selectedCharacter" || k === "selectedLanguage") {
            if (window.refreshAllSliders) {
                setTimeout(() => window.refreshAllSliders(), 50);
            }
        }
    });

    document.addEventListener("keyup", function (event) {
        if (event.key === "F8") {
            f8KeyPressed = false;
        }
    });

    // Monitor for consistency and errors
    setInterval(async () => {
        if (window.ensureVideoContextConsistency) {
            await window.ensureVideoContextConsistency();
        }
    }, 30000); // Check every 30 seconds

    // Personality sync: global event and wrappers
    (function setupPersonalitySync() {
        // Guard to avoid multiple initializations
        if (window._kimiPersonalitySyncReady) return;
        window._kimiPersonalitySyncReady = true;

        const dispatchUpdated = async (partialTraits, characterHint = null) => {
            try {
                const character = characterHint || (window.kimiDB && (await window.kimiDB.getSelectedCharacter())) || null;
                window.dispatchEvent(
                    new CustomEvent("personality:updated", {
                        detail: { character, traits: { ...partialTraits } }
                    })
                );
            } catch (e) {}
        };

        const tryWrapDB = () => {
            const db = window.kimiDB;
            if (!db) return false;

            const wrapOnce = (obj, methodName, buildTraitsFromArgs) => {
                if (!obj || typeof obj[methodName] !== "function") return;
                if (obj[methodName]._kimiWrapped) return;
                const original = obj[methodName].bind(obj);
                obj[methodName] = async function (...args) {
                    const res = await original(...args);
                    try {
                        const { traits, character } = await buildTraitsFromArgs(args, res);
                        if (traits && Object.keys(traits).length > 0) {
                            await dispatchUpdated(traits, character);
                        }
                    } catch (e) {}
                    return res;
                };
                obj[methodName]._kimiWrapped = true;
            };

            // setPersonalityTrait(trait, value, character?)
            wrapOnce(db, "setPersonalityTrait", async args => {
                const [trait, value, character] = args;
                return { traits: { [String(trait)]: Number(value) }, character: character || null };
            });

            // setPersonalityBatch(traitsObj, character?)
            wrapOnce(db, "setPersonalityBatch", async args => {
                const [traitsObj, character] = args;
                const traits = {};
                if (traitsObj && typeof traitsObj === "object") {
                    for (const [k, v] of Object.entries(traitsObj)) {
                        traits[String(k)] = Number(v);
                    }
                }
                return { traits, character: character || null };
            });

            // savePersonality(personalityObj, character?)
            wrapOnce(db, "savePersonality", async args => {
                const [personalityObj, character] = args;
                const traits = {};
                if (personalityObj && typeof personalityObj === "object") {
                    for (const [k, v] of Object.entries(personalityObj)) {
                        traits[String(k)] = Number(v);
                    }
                }
                return { traits, character: character || null };
            });

            return true;
        };

        // Try immediately and then retry a few times if DB not yet ready
        if (!tryWrapDB()) {
            let attempts = 0;
            const maxAttempts = 20;
            const interval = setInterval(() => {
                attempts++;
                if (tryWrapDB() || attempts >= maxAttempts) {
                    clearInterval(interval);
                }
            }, 250);
        }

        // Central listener: debounce UI/video sync to avoid thrashing
        let syncTimer = null;
        let lastTraits = {};
        window.addEventListener("personality:updated", async e => {
            try {
                if (e && e.detail && e.detail.traits) {
                    // Merge incremental updates
                    lastTraits = { ...lastTraits, ...e.detail.traits };
                }
            } catch {}

            if (syncTimer) clearTimeout(syncTimer);
            syncTimer = setTimeout(async () => {
                try {
                    const db = window.kimiDB;
                    const character = (e && e.detail && e.detail.character) || (db && (await db.getSelectedCharacter())) || null;
                    let traits = lastTraits;
                    if (!traits || Object.keys(traits).length === 0) {
                        // Fallback: fetch all traits if partial not provided
                        traits = db && (await db.getAllPersonalityTraits(character));
                    }

                    // 1) Update UI sliders if available
                    if (typeof window.updateSlider === "function" && traits) {
                        for (const [trait, value] of Object.entries(traits)) {
                            const id = `trait-${trait}`;
                            if (document.getElementById(id)) {
                                try {
                                    window.updateSlider(id, value);
                                } catch {}
                            }
                        }
                    }
                    if (typeof window.syncPersonalityTraits === "function") {
                        try {
                            await window.syncPersonalityTraits(character);
                        } catch {}
                    }

                    // 2) Update memory cache affection bar if available
                    if (window.kimiMemory && typeof window.kimiMemory.updateAffectionTrait === "function") {
                        try {
                            await window.kimiMemory.updateAffectionTrait();
                        } catch {}
                    }

                    // 3) Update video mood by personality
                    if (window.kimiVideo && typeof window.kimiVideo.setMoodByPersonality === "function") {
                        const allTraits =
                            traits && Object.keys(traits).length > 0
                                ? { ...traits }
                                : (db && (await db.getAllPersonalityTraits(character))) || {};
                        try {
                            window.kimiVideo.setMoodByPersonality(allTraits);
                        } catch {}
                        // 3b) Update voice modulation based on personality
                        try {
                            if (window.voiceManager && typeof window.voiceManager.updatePersonalityModulation === "function") {
                                window.voiceManager.updatePersonalityModulation(allTraits);
                            }
                        } catch {}
                    }

                    // 4) Ensure current video context is valid (lightweight guard)
                    let beforeInfo = null;
                    try {
                        if (window.kimiVideo && typeof window.kimiVideo.getCurrentVideoInfo === "function") {
                            beforeInfo = window.kimiVideo.getCurrentVideoInfo();
                        }
                    } catch {}

                    if (typeof window.ensureVideoContextConsistency === "function") {
                        try {
                            await window.ensureVideoContextConsistency();
                        } catch {}
                    }

                    try {
                        if (
                            window.KIMI_DEBUG_SYNC &&
                            window.kimiVideo &&
                            typeof window.kimiVideo.getCurrentVideoInfo === "function"
                        ) {
                            const afterInfo = window.kimiVideo.getCurrentVideoInfo();
                            if (
                                beforeInfo &&
                                afterInfo &&
                                (beforeInfo.context !== afterInfo.context ||
                                    beforeInfo.emotion !== afterInfo.emotion ||
                                    beforeInfo.category !== afterInfo.category)
                            ) {
                                console.log("🔧 SyncGuard: corrected video context", { from: beforeInfo, to: afterInfo });
                            }
                        }
                    } catch {}
                } catch {
                } finally {
                    lastTraits = {};
                }
            }, 120); // small debounce
        });
    })();
});