Upload 29 files

index.html

@@ -397,28 +397,26 @@
                         </div>
 
                         <div class="config-row">
-                            <div class="config-label-group">
-                                <label class="config-label" id="api-key-label" data-i18n="api_key_label">API Key</label>
-                                <span id="api-key-info" class="help-icon" data-i18n-title="api_key_help_title"
-                                    title="Saved = your API key is stored for this provider. Use Test API Key to verify the connection.">
-                                    <i class="fas fa-info-circle"></i>
-                                </span>
-                                <span id="api-key-presence" class="presence-dot" aria-label="API key presence"
-                                    data-i18n-title="api_key_presence_hint"
-                                    title="Green = API key saved for current provider. Grey = no key saved."></span>
-                            </div>
+                            <label class="config-label" id="api-key-label" data-i18n="api_key_label">API Key</label>
                             <div class="config-control">
-                                <input type="text" class="kimi-input" id="provider-api-key" name="config-token"
-                                    placeholder="API Key..." autocomplete="one-time-code" autocapitalize="none"
-                                    autocorrect="off" spellcheck="false" inputmode="text" aria-autocomplete="none"
-                                    data-lpignore="true" data-1p-ignore="true" data-bwignore="true"
-                                    data-form-type="other" />
-                                <button class="kimi-button" id="toggle-api-key" type="button" aria-pressed="false"
-                                    aria-label="Show API key">
-                                    <i class="fas fa-eye"></i>
-                                </button>
-                                <span id="api-key-saved" data-i18n="saved"
-                                    style="display:none;margin-left:8px;color:#4caf50;font-weight:600;">Saved</span>
+                                <div class="api-key-input-group">
+                                    <input type="text" class="kimi-input" id="provider-api-key" name="config-token"
+                                        placeholder="API Key..." autocomplete="one-time-code" autocapitalize="none"
+                                        autocorrect="off" spellcheck="false" inputmode="text" aria-autocomplete="none"
+                                        data-lpignore="true" data-1p-ignore="true" data-bwignore="true"
+                                        data-form-type="other" />
+                                    <button class="kimi-button api-key-toggle" id="toggle-api-key" type="button"
+                                        aria-pressed="false" aria-label="Show API key">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <span id="api-key-presence" class="presence-dot" aria-label="API key presence"
+                                        data-i18n-title="api_key_presence_hint"
+                                        title="Green = API key saved for current provider. Grey = no key saved."></span>
+                                </div>
+                                <div class="api-key-status">
+                                    <span id="api-key-saved" data-i18n="saved"
+                                        style="display:none;color:#4caf50;font-weight:600;">Saved</span>
+                                </div>
                             </div>
                         </div>
 

kimi-css/kimi-settings.css

@@ -114,15 +114,6 @@
     backdrop-filter: blur(10px);
 }
 
-.help-icon {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    width: 18px;
-    height: 18px;
-    color: var(--modal-text);
-}
-
 .help-button:hover,
 .settings-close:hover {
     background-color: var(--modal-close-hover-bg);
@@ -310,13 +301,6 @@
     opacity: 0.9;
 }
 
-.config-label-group {
-    display: inline-flex;
-    align-items: center;
-    gap: 8px;
-    flex: 1;
-}
-
 .presence-dot {
     display: inline-block;
     width: 10px;
@@ -1553,3 +1537,92 @@
     outline: 2px solid var(--primary-pink);
     outline-offset: 2px;
 }
+
+/* ===== API KEY INPUT STYLING ===== */
+
+.api-key-input-group {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    position: relative;
+}
+
+.api-key-input-group .kimi-input {
+    flex: 1;
+    margin: 0;
+}
+
+.api-key-toggle {
+    min-width: 40px;
+    height: 40px;
+    padding: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 6px;
+    background: var(--settings-bg-secondary, rgba(255, 255, 255, 0.08));
+    border: 1px solid var(--settings-border-color, rgba(255, 255, 255, 0.15));
+    color: var(--settings-text, #ffffff);
+    transition: all 0.2s ease;
+    cursor: pointer;
+}
+
+.api-key-toggle:hover {
+    background: var(--settings-bg-hover, rgba(255, 255, 255, 0.12));
+    border-color: var(--accent-color, #8a2be2);
+}
+
+.api-key-toggle:active {
+    transform: scale(0.95);
+}
+
+.api-key-input-group .presence-dot {
+    width: 12px;
+    height: 12px;
+    margin-left: 4px;
+    border: 2px solid var(--settings-bg-primary, rgba(0, 0, 0, 0.3));
+    box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.1);
+    transition: all 0.2s ease;
+}
+
+.api-key-status {
+    margin-top: 6px;
+    min-height: 18px;
+    display: flex;
+    align-items: center;
+}
+
+.api-key-status span {
+    font-size: 0.85rem;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.api-key-status span::before {
+    content: "✓";
+    font-weight: bold;
+    font-size: 0.9rem;
+}
+
+/* Responsive adjustments */
+@media (max-width: 600px) {
+    .api-key-input-group {
+        flex-direction: column;
+        align-items: stretch;
+        gap: 12px;
+    }
+
+    .api-key-toggle {
+        align-self: flex-end;
+        min-width: 100px;
+    }
+
+    .api-key-input-group .presence-dot {
+        position: absolute;
+        top: 50%;
+        right: 8px;
+        transform: translateY(-50%);
+        z-index: 10;
+    }
+}

kimi-js/kimi-llm-manager.js

@@ -501,8 +501,8 @@ class KimiLLMManager {
     async chatWithOpenAICompatible(userMessage, options = {}) {
         const baseUrl = await this.db.getPreference("llmBaseUrl", "https://api.openai.com/v1/chat/completions");
         const provider = await this.db.getPreference("llmProvider", "openai");
-        const apiKey = KimiProviderUtils
-            ? await KimiProviderUtils.getApiKey(this.db, provider)
+        const apiKey = window.KimiProviderUtils
+            ? await window.KimiProviderUtils.getApiKey(this.db, provider)
             : await this.db.getPreference("providerApiKey", "");
         const modelId = await this.db.getPreference("llmModelId", this.currentModel || "gpt-4o-mini");
         if (!apiKey) {
@@ -606,7 +606,10 @@ class KimiLLMManager {
     }
 
     async chatWithOpenRouter(userMessage, options = {}) {
-        const apiKey = await this.db.getPreference("providerApiKey");
+        const provider = await this.db.getPreference("llmProvider", "openrouter");
+        const apiKey = await (window.KimiProviderUtils
+            ? window.KimiProviderUtils.getApiKey(this.db, provider)
+            : this.db.getPreference("providerApiKey"));
         if (!apiKey) {
             throw new Error("OpenRouter API key not configured");
         }
@@ -916,7 +919,10 @@ class KimiLLMManager {
     // ===== STREAMING METHODS =====
 
     async chatWithOpenRouterStreaming(userMessage, onToken, options = {}) {
-        const apiKey = await this.db.getPreference("providerApiKey");
+        const provider = await this.db.getPreference("llmProvider", "openrouter");
+        const apiKey = await (window.KimiProviderUtils
+            ? window.KimiProviderUtils.getApiKey(this.db, provider)
+            : this.db.getPreference("providerApiKey"));
         if (!apiKey) {
             throw new Error("OpenRouter API key not configured");
         }
@@ -1047,9 +1053,12 @@ class KimiLLMManager {
 
     async chatWithOpenAICompatibleStreaming(userMessage, onToken, options = {}) {
         const baseUrl = await this.db.getPreference("llmBaseUrl", "https://api.openai.com/v1/chat/completions");
-        const apiKey = await this.db.getPreference("openaiApiKey");
+        const provider = await this.db.getPreference("llmProvider", "openai");
+        const apiKey = window.KimiProviderUtils
+            ? await window.KimiProviderUtils.getApiKey(this.db, provider)
+            : await this.db.getPreference("providerApiKey", "");
         if (!apiKey) {
-            throw new Error("OpenAI API key not configured");
+            throw new Error("API key not configured for selected provider");
         }
 
         const systemPromptContent = await this.assemblePrompt(userMessage);
@@ -1410,7 +1419,14 @@ class KimiLLMManager {
                     testWord = "Hello";
             }
             const systemPrompt = "You are a helpful assistant.";
-            let apiKey = await this.db.getPreference("providerApiKey");
+            let apiKey = await (window.KimiProviderUtils
+                ? window.KimiProviderUtils.getApiKey(this.db, provider)
+                : this.db.getPreference("providerApiKey"));
+
+            if (!apiKey) {
+                return { success: false, error: "No API key found for provider: " + provider };
+            }
+
             let baseUrl = "";
             let payload = {
                 model: modelId,
@@ -1442,6 +1458,7 @@ class KimiLLMManager {
             } else {
                 throw new Error("Unknown provider: " + provider);
             }
+
             const response = await fetch(baseUrl, {
                 method: "POST",
                 headers,
@@ -1497,7 +1514,10 @@ class KimiLLMManager {
         if (this._isRefreshingModels) return;
         this._isRefreshingModels = true;
         try {
-            const apiKey = await this.db.getPreference("providerApiKey", "");
+            const provider = await this.db.getPreference("llmProvider", "openrouter");
+            const apiKey = await (window.KimiProviderUtils
+                ? window.KimiProviderUtils.getApiKey(this.db, provider)
+                : this.db.getPreference("providerApiKey", ""));
             const res = await fetch("https://openrouter.ai/api/v1/models", {
                 method: "GET",
                 headers: {

kimi-js/kimi-module.js

@@ -847,8 +847,13 @@ async function loadSettingsData() {
         // Update API key input
         const apiKeyInput = document.getElementById("provider-api-key");
         if (apiKeyInput) {
-            const keyPref = window.KimiProviderUtils ? window.KimiProviderUtils.getKeyPrefForProvider(provider) : null;
-            const providerKey = keyPref && preferences[keyPref] ? preferences[keyPref] : apiKey;
+            // Get the API key for the current provider
+            let providerKey = "";
+            if (window.KimiProviderUtils) {
+                providerKey = await window.KimiProviderUtils.getApiKey(kimiDB, provider);
+            } else {
+                providerKey = apiKey; // fallback to old method
+            }
             apiKeyInput.value = providerKey || "";
         }
         const providerSelect = document.getElementById("llm-provider");
@@ -1557,15 +1562,10 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
     const interfaceOpacitySlider = document.getElementById("interface-opacity");
     const animationsToggle = document.getElementById("animations-toggle");
 
-    // Cleanup existing listeners to prevent memory leaks
-    const cleanupListeners = () => {
-        if (window._kimiListenerCleanup) {
-            window._kimiListenerCleanup.forEach(cleanup => cleanup());
-        }
+    // SIMPLE FIX: Initialize _kimiListenerCleanup to prevent undefined error
+    if (!window._kimiListenerCleanup) {
         window._kimiListenerCleanup = [];
-    };
-
-    cleanupListeners();
+    }
 
     // Create debounced functions for better performance
     const debouncedVoiceRateUpdate = window.KimiPerformanceUtils?.debounce(async value => {
@@ -1656,22 +1656,12 @@ function setupSettingsListeners(kimiDB, kimiMemory) {
         voiceVolumeSlider.addEventListener("input", listener);
         window._kimiListenerCleanup.push(() => voiceVolumeSlider.removeEventListener("input", listener));
     }
-    if (languageSelect) {
-        languageSelect.removeEventListener("change", window._kimiLanguageListener);
-        window._kimiLanguageListener = async e => {
-            if (kimiDB) await kimiDB.setPreference("selectedLanguage", e.target.value);
-            if (window.voiceManager && window.voiceManager.initVoices) await window.voiceManager.initVoices();
-        };
-        languageSelect.addEventListener("change", window._kimiLanguageListener);
-    }
-    if (voiceSelect) {
-        voiceSelect.removeEventListener("change", window._kimiVoiceSelectListener);
-        window._kimiVoiceSelectListener = async e => {
-            if (kimiDB) await kimiDB.setPreference("selectedVoice", e.target.value);
-            if (window.voiceManager && window.voiceManager.initVoices) await window.voiceManager.initVoices();
-        };
-        voiceSelect.addEventListener("change", window._kimiVoiceSelectListener);
-    }
+    // Note: Language selector event listener is now handled by VoiceManager.setupLanguageSelector()
+    // This prevents duplicate event listeners and ensures proper voice/language coordination
+
+    // Note: Voice selector event listener is now handled by VoiceManager.updateVoiceSelector()
+    // This prevents duplicate event listeners and ensures proper voice preference coordination
+
     // Batch personality traits optimization
     let personalityBatchTimeout = null;
     const pendingTraitChanges = {};

kimi-js/kimi-script.js

@@ -693,7 +693,6 @@ document.addEventListener("DOMContentLoaded", async function () {
                 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";
 
@@ -877,23 +876,25 @@ document.addEventListener("DOMContentLoaded", async function () {
 
     // Function definitions
     function setupUnifiedEventHandlers() {
-        // Cleanup existing event handlers
-        if (window._kimiEventCleanup && Array.isArray(window._kimiEventCleanup)) {
-            window._kimiEventCleanup.forEach(cleanup => {
-                if (typeof cleanup === "function") cleanup();
-            });
+        // SIMPLE FIX: Initialize _kimiEventCleanup to prevent undefined error
+        if (!window._kimiEventCleanup) {
+            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;
-                window._kimiEventCleanup.push(() => {
+
+                // Simple cleanup system
+                const cleanupFn = () => {
                     element.removeEventListener(event, handler);
                     element[identifier] = false;
-                });
+                };
+
+                // Store cleanup function in the simple array
+                window._kimiEventCleanup.push(cleanupFn);
             }
         }
 
@@ -924,24 +925,8 @@ document.addEventListener("DOMContentLoaded", async function () {
         window.kimiI18nManager = new window.KimiI18nManager();
         const lang = await kimiDB.getPreference("selectedLanguage", "en");
         await window.kimiI18nManager.setLanguage(lang);
-        const langSelect = document.getElementById("language-selection");
-        if (langSelect) {
-            langSelect.value = lang;
-            langSelect.addEventListener("change", async function (e) {
-                const selectedLang = e.target.value;
-                await kimiDB.setPreference("selectedLanguage", selectedLang);
-                await window.kimiI18nManager.setLanguage(selectedLang);
-
-                if (window.voiceManager && window.voiceManager.handleLanguageChange) {
-                    await window.voiceManager.handleLanguageChange({ target: { value: selectedLang } });
-                }
-
-                // Refresh the personality prompt to include new language instruction
-                if (window.kimiLLM && window.kimiLLM.refreshMemoryContext) {
-                    await window.kimiLLM.refreshMemoryContext();
-                }
-            });
-        }
+        // 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();
     }

kimi-js/kimi-utils.js

@@ -22,7 +22,7 @@ window.KimiValidationUtils = {
     validateRange(value, key) {
         const bounds = {
             voiceRate: { min: 0.5, max: 2, def: 1.1 },
-            voicePitch: { min: 0, max: 2, def: 1.0 },
+            voicePitch: { min: 0.5, max: 2, def: 1.1 },
             voiceVolume: { min: 0, max: 1, def: 0.8 },
             llmTemperature: { min: 0, max: 1, def: 0.9 },
             llmMaxTokens: { min: 1, max: 8192, def: 400 },
@@ -1818,10 +1818,8 @@ class KimiVideoManager {
     }
 
     // METHODS TO ANALYZE EMOTIONS FROM TEXT
-    analyzeTextEmotion(text) {
-        // Use unified emotion system
-        return window.kimiAnalyzeEmotion ? window.kimiAnalyzeEmotion(text, "auto") : "neutral";
-    } // CLEANUP
+    // Note: analyzeTextEmotion() moved to KimiVoiceManager for centralized emotion analysis
+    // CLEANUP
     destroy() {
         clearTimeout(this.autoTransitionTimer);
         this.autoTransitionTimer = null;

kimi-js/kimi-voices.js

@@ -7,7 +7,7 @@ class KimiVoiceManager {
 
         // Voice properties
         this.speechSynthesis = window.speechSynthesis;
-        this.kimiEnglishVoice = null;
+        this.currentVoice = null;
         this.availableVoices = [];
 
         // Speech recognition
@@ -31,8 +31,8 @@ class KimiVoiceManager {
         this.transcriptHideTimeout = null;
         this.listeningTimeout = null;
 
-        // Selected character for responses
-        this.selectedCharacter = "Kimi";
+        // Selected character for responses (will be updated from database)
+        this.selectedCharacter = window.KIMI_CONFIG?.DEFAULTS?.SELECTED_CHARACTER || "Kimi";
 
         // Speaking flag
         this.isSpeaking = false;
@@ -54,6 +54,7 @@ class KimiVoiceManager {
         // Browser detection
         this.browser = this._detectBrowser();
     }
+
     // ===== INITIALIZATION =====
     async init() {
         // Avoid double initialization
@@ -83,7 +84,13 @@ class KimiVoiceManager {
 
             // Initialize voice synthesis
             await this.initVoices();
-            this.setupVoicesChangedListener();
+
+            // Only setup listener once during initialization
+            if (!this._voicesListenerSetup) {
+                this.setupVoicesChangedListener();
+                this._voicesListenerSetup = true;
+            }
+
             this.setupLanguageSelector();
 
             // Initialize speech recognition
@@ -93,14 +100,19 @@ class KimiVoiceManager {
             // Check current microphone permission status
             await this.checkMicrophonePermission();
 
-            // Initialize selected character
+            // Initialize selected character with proper display name
             if (this.db && typeof this.db.getSelectedCharacter === "function") {
-                const char = await this.db.getSelectedCharacter();
-                if (char) this.selectedCharacter = char;
+                const charKey = await this.db.getSelectedCharacter();
+                if (charKey && window.KIMI_CHARACTERS && window.KIMI_CHARACTERS[charKey]) {
+                    // Use the display name, not the key
+                    this.selectedCharacter = window.KIMI_CHARACTERS[charKey].name;
+                } else if (charKey) {
+                    // Fallback to key if KIMI_CHARACTERS not available
+                    this.selectedCharacter = charKey;
+                }
             }
 
             this.isInitialized = true;
-            console.log("🎤 VoiceManager initialized successfully");
             return true;
         } catch (error) {
             console.error("Error during VoiceManager initialization:", error);
@@ -158,18 +170,16 @@ class KimiVoiceManager {
 
             if (!navigator.permissions) {
                 console.log("🎤 Permissions API not available");
+                this.micPermissionGranted = false; // Set default state
                 return;
             }
 
             const permissionStatus = await navigator.permissions.query({ name: "microphone" });
             this.micPermissionGranted = permissionStatus.state === "granted";
 
-            console.log("🎤 Initial microphone permission status:", permissionStatus.state);
-
             // Listen for permission changes
             permissionStatus.addEventListener("change", () => {
                 this.micPermissionGranted = permissionStatus.state === "granted";
-                console.log("🎤 Microphone permission changed to:", permissionStatus.state);
             });
         } catch (error) {
             console.log("🎤 Could not check microphone permission:", error);
@@ -187,6 +197,13 @@ class KimiVoiceManager {
 
         this.availableVoices = this.speechSynthesis.getVoices();
 
+        // Handle case where voices are not loaded yet (common timing issue)
+        if (this.availableVoices.length === 0) {
+            this._initializingVoices = false;
+            // The onvoiceschanged listener will retry initialization
+            return;
+        }
+
         // Only get language from DB if not already set
         if (!this.selectedLanguage) {
             const selectedLanguage = await this.db?.getPreference("selectedLanguage", "en");
@@ -195,43 +212,146 @@ class KimiVoiceManager {
 
         const savedVoice = await this.db?.getPreference("selectedVoice", "auto");
 
-        let filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().startsWith(this.selectedLanguage));
-        if (filteredVoices.length === 0) {
-            filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().includes(this.selectedLanguage));
-        }
-        if (filteredVoices.length === 0) {
-            // As a last resort, use any available voice
-            filteredVoices = this.availableVoices;
-        }
+        const filteredVoices = this.getVoicesForLanguage(this.selectedLanguage);
 
         if (savedVoice && savedVoice !== "auto") {
-            let foundVoice = filteredVoices.find(voice => voice.name === savedVoice);
-            if (!foundVoice) {
-                foundVoice = this.availableVoices.find(voice => voice.name === savedVoice);
-            }
+            // Only search within language-compatible voices
+            const foundVoice = filteredVoices.find(voice => voice.name === savedVoice);
             if (foundVoice) {
-                this.kimiEnglishVoice = foundVoice;
-                this.updateVoiceSelector();
-                this._initializingVoices = false;
-                return;
-            } else if (filteredVoices.length > 0) {
-                this.kimiEnglishVoice = filteredVoices[0];
-                await this.db?.setPreference("selectedVoice", this.kimiEnglishVoice.name);
+                this.currentVoice = foundVoice;
+                console.log(
+                    `🎤 Voice restored from cache: "${foundVoice.name}" (${foundVoice.lang}) for language "${this.selectedLanguage}"`
+                );
                 this.updateVoiceSelector();
                 this._initializingVoices = false;
                 return;
+            } else {
+                // Saved voice not compatible with current language, fall back to auto-selection
+                console.log(
+                    `🎤 Saved voice "${savedVoice}" not compatible with language "${this.selectedLanguage}", using auto-selection`
+                );
+                await this.db?.setPreference("selectedVoice", "auto");
             }
         }
 
-        // Prefer female voices if available, otherwise fallback
-        const femaleVoice = filteredVoices.find(
-            voice =>
-                voice.name.toLowerCase().includes("female") ||
-                (voice.gender && voice.gender.toLowerCase() === "female") ||
-                voice.name.toLowerCase().includes("woman") ||
-                voice.name.toLowerCase().includes("girl")
-        );
-        this.kimiEnglishVoice = femaleVoice || filteredVoices[0] || this.availableVoices[0];
+        // Prefer female voices if available in the language-compatible voices
+        // Use real voice names since voice.gender is rarely provided by browsers
+        const femaleVoice = filteredVoices.find(voice => {
+            const name = voice.name.toLowerCase();
+
+            // Common female voice names across different platforms
+            const femaleNames = [
+                // Microsoft voices
+                "aria",
+                "emma",
+                "jenny",
+                "michelle",
+                "karen",
+                "heather",
+                "susan",
+                "joanna",
+                "salli",
+                "kimberly",
+                "kendra",
+                "ivy",
+                "rebecca",
+                "zira",
+                "eva",
+                "linda",
+                "denise",
+                "elsa",
+                "nathalie",
+                "julie",
+                "hortense",
+                "marie",
+                "pauline",
+                "claudia",
+                "lucia",
+                "paola",
+                "bianca",
+                "cosima",
+                "katja",
+                "hedda",
+                "helena",
+                "naayf",
+                "sabina",
+                "naja",
+                "sara",
+                "amelie",
+                "lea",
+                "manon",
+
+                // Google voices
+                "wavenet-a",
+                "wavenet-c",
+                "wavenet-e",
+                "wavenet-f",
+                "wavenet-g",
+                "standard-a",
+                "standard-c",
+                "standard-e",
+
+                // Apple voices
+                "allison",
+                "ava",
+                "samantha",
+                "susan",
+                "vicki",
+                "victoria",
+                "audrey",
+                "aurelie",
+                "marie",
+                "thomas",
+                "amelie",
+
+                // General keywords
+                "female",
+                "woman",
+                "girl",
+                "lady"
+            ];
+
+            // Check if voice name contains any female name
+            return (
+                femaleNames.some(femaleName => name.includes(femaleName)) ||
+                (voice.gender && voice.gender.toLowerCase() === "female")
+            );
+        });
+
+        // Debug: Check what we actually found
+        if (femaleVoice) {
+            console.log(`🎤 Female voice found: "${femaleVoice.name}" (${femaleVoice.lang})`);
+        } else {
+            console.log(
+                `🎤 No female voice found, using first available: "${filteredVoices[0]?.name}" (${filteredVoices[0]?.lang})`
+            );
+            // Debug: Show what voices are available and why they don't match
+            if (filteredVoices.length > 0 && filteredVoices.length <= 5) {
+                console.log(
+                    `🎤 Available voices for ${this.selectedLanguage}:`,
+                    filteredVoices.map(v => ({
+                        name: v.name,
+                        lang: v.lang,
+                        gender: v.gender || "undefined"
+                    }))
+                );
+            }
+        }
+
+        // Use female voice if found, otherwise first compatible voice, with proper fallback
+        this.currentVoice = femaleVoice || filteredVoices[0] || null;
+
+        if (!this.currentVoice) {
+            console.warn("🎤 No voices available for speech synthesis - this may resolve automatically when voices load");
+            this._initializingVoices = false;
+            // Don't return here - let the system continue, voices may load later via onvoiceschanged
+            // The updateVoiceSelector will handle the empty state gracefully
+        } else {
+            // Log successful voice selection with language info
+            console.log(
+                `🎤 Voice loaded: "${this.currentVoice.name}" (${this.currentVoice.lang}) for language "${this.selectedLanguage}"`
+            );
+        }
 
         // Do not overwrite "auto" preference here; only update if user selects a specific voice
 
@@ -254,47 +374,184 @@ class KimiVoiceManager {
         autoOption.textContent = "Automatic (Best voice for selected language)";
         voiceSelect.appendChild(autoOption);
 
-        let filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().startsWith(this.selectedLanguage));
-        if (filteredVoices.length === 0) {
-            filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().includes(this.selectedLanguage));
-        }
+        const filteredVoices = this.getVoicesForLanguage(this.selectedLanguage);
+
         if (filteredVoices.length === 0) {
-            // Show all voices if none match the selected language
-            filteredVoices = this.availableVoices;
+            // Add a placeholder option when no voices are available
+            const noVoicesOption = document.createElement("option");
+            noVoicesOption.value = "none";
+            noVoicesOption.textContent = "No voices available (loading...)";
+            noVoicesOption.disabled = true;
+            voiceSelect.appendChild(noVoicesOption);
+        } else {
+            filteredVoices.forEach(voice => {
+                const option = document.createElement("option");
+                option.value = voice.name;
+                option.textContent = `${voice.name} (${voice.lang})`;
+                if (this.currentVoice && voice.name === this.currentVoice.name) {
+                    option.selected = true;
+                }
+                voiceSelect.appendChild(option);
+            });
         }
 
-        filteredVoices.forEach(voice => {
-            const option = document.createElement("option");
-            option.value = voice.name;
-            option.textContent = `${voice.name} (${voice.lang})`;
-            if (this.kimiEnglishVoice && voice.name === this.kimiEnglishVoice.name) {
-                option.selected = true;
-            }
-            voiceSelect.appendChild(option);
-        });
+        // Remove existing handler before adding new one
+        if (this.voiceChangeHandler) {
+            voiceSelect.removeEventListener("change", this.voiceChangeHandler);
+        }
 
-        voiceSelect.removeEventListener("change", this.handleVoiceChange);
-        voiceSelect.addEventListener("change", this.handleVoiceChange.bind(this));
+        // Create and store the handler
+        this.voiceChangeHandler = this.handleVoiceChange.bind(this);
+        voiceSelect.addEventListener("change", this.voiceChangeHandler);
     }
 
     async handleVoiceChange(e) {
         if (e.target.value === "auto") {
+            console.log(`🎤 Voice set to automatic selection for language "${this.selectedLanguage}"`);
             await this.db?.setPreference("selectedVoice", "auto");
-            this.kimiEnglishVoice = null; // Trigger auto-selection next time
+            this.currentVoice = null; // Trigger auto-selection next time
         } else {
-            this.kimiEnglishVoice = this.availableVoices.find(voice => voice.name === e.target.value);
+            this.currentVoice = this.availableVoices.find(voice => voice.name === e.target.value);
+            console.log(`🎤 Voice manually selected: "${this.currentVoice?.name}" (${this.currentVoice?.lang})`);
             await this.db?.setPreference("selectedVoice", e.target.value);
         }
     }
 
     setupVoicesChangedListener() {
         if (this.speechSynthesis.onvoiceschanged !== undefined) {
-            this.speechSynthesis.onvoiceschanged = async () => await this.initVoices();
+            // Prevent multiple event listeners
+            this.speechSynthesis.onvoiceschanged = null;
+            this.speechSynthesis.onvoiceschanged = async () => {
+                // Only reinitialize if voices are actually available now
+                if (this.speechSynthesis.getVoices().length > 0) {
+                    await this.initVoices();
+                }
+            };
+        }
+
+        // Fallback: Only use timeout if onvoiceschanged is not supported
+        if (this.availableVoices.length === 0 && this.speechSynthesis.onvoiceschanged === undefined) {
+            setTimeout(async () => {
+                await this.initVoices();
+            }, 1000);
+        }
+    }
+
+    // ===== LANGUAGE UTILITIES =====
+    getLanguageCode(langShort) {
+        const languageMap = {
+            en: "en-US",
+            fr: "fr-FR",
+            es: "es-ES",
+            de: "de-DE",
+            it: "it-IT",
+            ja: "ja-JP",
+            zh: "zh-CN"
+        };
+        return languageMap[langShort] || langShort;
+    }
+
+    getVoicesForLanguage(language) {
+        let filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().startsWith(language));
+        if (filteredVoices.length === 0) {
+            filteredVoices = this.availableVoices.filter(voice => voice.lang.toLowerCase().includes(language));
+        }
+        if (filteredVoices.length === 0) {
+            // As last resort, return all voices
+            filteredVoices = this.availableVoices;
+        }
+        return filteredVoices;
+    }
+
+    // ===== VOICE PREFERENCE UTILITIES =====
+    getVoicePreference(paramType, options = {}) {
+        // Hierarchy: options > memory.preferences > kimiMemory.preferences > DOM element > default
+        const defaults = {
+            rate: window.KIMI_CONFIG?.DEFAULTS?.VOICE_RATE || 1.1,
+            pitch: window.KIMI_CONFIG?.DEFAULTS?.VOICE_PITCH || 1.1,
+            volume: window.KIMI_CONFIG?.DEFAULTS?.VOICE_VOLUME || 0.8
+        };
+
+        const elementIds = {
+            rate: "voice-rate",
+            pitch: "voice-pitch",
+            volume: "voice-volume"
+        };
+
+        const memoryKeys = {
+            rate: "voiceRate",
+            pitch: "voicePitch",
+            volume: "voiceVolume"
+        };
+
+        // 1. Check options parameter
+        if (options[paramType] !== undefined) {
+            return parseFloat(options[paramType]);
+        }
+
+        // 2. Check local memory preferences
+        if (this.memory?.preferences?.[memoryKeys[paramType]] !== undefined) {
+            return parseFloat(this.memory.preferences[memoryKeys[paramType]]);
+        }
+
+        // 3. Check global memory preferences
+        if (window.kimiMemory?.preferences?.[memoryKeys[paramType]] !== undefined) {
+            return parseFloat(window.kimiMemory.preferences[memoryKeys[paramType]]);
         }
+
+        // 4. Check DOM element
+        const element = document.getElementById(elementIds[paramType]);
+        if (element) {
+            return parseFloat(element.value);
+        }
+
+        // 5. Return default value
+        return defaults[paramType];
+    }
+
+    // ===== CHAT MESSAGE UTILITIES =====
+    handleChatMessage(userMessage, kimiResponse) {
+        const chatContainer = document.getElementById("chat-container");
+        const chatMessages = document.getElementById("chat-messages");
+
+        if (!chatContainer || !chatContainer.classList.contains("visible") || !chatMessages) {
+            return;
+        }
+
+        const addMessageToChat = window.addMessageToChat || (typeof addMessageToChat !== "undefined" ? addMessageToChat : null);
+
+        if (addMessageToChat) {
+            addMessageToChat("user", userMessage);
+            addMessageToChat(this.selectedCharacter.toLowerCase(), kimiResponse);
+        } else {
+            // Fallback manual message creation
+            this.createChatMessage(chatMessages, "user", userMessage);
+            this.createChatMessage(chatMessages, this.selectedCharacter.toLowerCase(), kimiResponse);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+    }
+
+    createChatMessage(container, sender, text) {
+        const messageDiv = document.createElement("div");
+        messageDiv.className = `message ${sender}`;
+
+        const textDiv = document.createElement("div");
+        textDiv.textContent = text;
+
+        const timeDiv = document.createElement("div");
+        timeDiv.className = "message-time";
+        timeDiv.textContent = new Date().toLocaleTimeString("en-US", {
+            hour: "2-digit",
+            minute: "2-digit"
+        });
+
+        messageDiv.appendChild(textDiv);
+        messageDiv.appendChild(timeDiv);
+        container.appendChild(messageDiv);
     }
 
     async speak(text, options = {}) {
-        if (!text || !this.kimiEnglishVoice) {
+        if (!text || !this.currentVoice) {
             console.warn("Unable to speak: empty text or voice not initialized");
             return;
         }
@@ -306,30 +563,9 @@ class KimiVoiceManager {
         // Clean text for better speech synthesis
         let processedText = this._normalizeForSpeech(text);
 
-        // Detect emotional content for voice adjustments
-        let customRate = options.rate;
-        if (customRate === undefined) {
-            customRate = this.memory?.preferences?.voiceRate;
-        }
-        if (customRate === undefined) {
-            customRate = window.kimiMemory?.preferences?.voiceRate;
-        }
-        if (customRate === undefined) {
-            const rateSlider = document.getElementById("voice-rate");
-            customRate = rateSlider ? parseFloat(rateSlider.value) : 1.1;
-        }
-
-        let customPitch = options.pitch;
-        if (customPitch === undefined) {
-            customPitch = this.memory?.preferences?.voicePitch;
-        }
-        if (customPitch === undefined) {
-            customPitch = window.kimiMemory?.preferences?.voicePitch;
-        }
-        if (customPitch === undefined) {
-            const pitchSlider = document.getElementById("voice-pitch");
-            customPitch = pitchSlider ? parseFloat(pitchSlider.value) : 1.1;
-        }
+        // Get voice settings using centralized utility
+        let customRate = this.getVoicePreference("rate", options);
+        let customPitch = this.getVoicePreference("pitch", options);
 
         // Check for emotional indicators in original text (before processing)
         const lowerText = text.toLowerCase();
@@ -347,26 +583,12 @@ class KimiVoiceManager {
         }
 
         const utterance = new SpeechSynthesisUtterance(processedText);
-        utterance.voice = this.kimiEnglishVoice;
+        utterance.voice = this.currentVoice;
         utterance.rate = customRate;
         utterance.pitch = customPitch;
 
-        // Get volume from multiple sources with fallback hierarchy
-        let volume = options.volume;
-        if (volume === undefined) {
-            // Try to get from memory preferences
-            volume = this.memory?.preferences?.voiceVolume;
-        }
-        if (volume === undefined) {
-            // Try to get from kimiMemory global
-            volume = window.kimiMemory?.preferences?.voiceVolume;
-        }
-        if (volume === undefined) {
-            // Try to get directly from slider
-            const volumeSlider = document.getElementById("voice-volume");
-            volume = volumeSlider ? parseFloat(volumeSlider.value) : 0.8;
-        }
-        utterance.volume = volume;
+        // Get volume using centralized utility
+        utterance.volume = this.getVoicePreference("volume", options);
         const emotionFromText = this.analyzeTextEmotion(text);
         if (window.kimiVideo && emotionFromText !== "neutral") {
             requestAnimationFrame(() => {
@@ -585,9 +807,7 @@ class KimiVoiceManager {
         }
         this.recognition = new this.SpeechRecognition();
         this.recognition.continuous = true;
-        let langCode = this.selectedLanguage || "en";
-        if (langCode === "fr") langCode = "fr-FR";
-        if (langCode === "en") langCode = "en-US";
+        const langCode = this.getLanguageCode(this.selectedLanguage || "en");
         this.recognition.lang = langCode;
         this.recognition.interimResults = true;
 
@@ -629,112 +849,18 @@ class KimiVoiceManager {
                         this.stopListening();
                     }, this.silenceTimeout);
                     (async () => {
+                        let response;
                         if (typeof window.analyzeAndReact === "function") {
-                            const response = await window.analyzeAndReact(final_transcript);
-                            if (response) {
-                                const chatContainer = document.getElementById("chat-container");
-                                const chatMessages = document.getElementById("chat-messages");
-                                if (chatContainer && chatContainer.classList.contains("visible") && chatMessages) {
-                                    const addMessageToChat =
-                                        window.addMessageToChat ||
-                                        (typeof addMessageToChat !== "undefined" ? addMessageToChat : null);
-                                    if (addMessageToChat) {
-                                        addMessageToChat("user", final_transcript);
-                                        addMessageToChat("kimi", response);
-                                    } else {
-                                        const userDiv = document.createElement("div");
-                                        userDiv.className = "message user";
-
-                                        const userMessageDiv = document.createElement("div");
-                                        userMessageDiv.textContent = final_transcript;
-
-                                        const userTimeDiv = document.createElement("div");
-                                        userTimeDiv.className = "message-time";
-                                        userTimeDiv.textContent = new Date().toLocaleTimeString("en-US", {
-                                            hour: "2-digit",
-                                            minute: "2-digit"
-                                        });
-
-                                        userDiv.appendChild(userMessageDiv);
-                                        userDiv.appendChild(userTimeDiv);
-                                        chatMessages.appendChild(userDiv);
-
-                                        const kimiDiv = document.createElement("div");
-                                        kimiDiv.className = "message kimi";
-
-                                        const kimiMessageDiv = document.createElement("div");
-                                        kimiMessageDiv.textContent = response;
-
-                                        const kimiTimeDiv = document.createElement("div");
-                                        kimiTimeDiv.className = "message-time";
-                                        kimiTimeDiv.textContent = new Date().toLocaleTimeString("en-US", {
-                                            hour: "2-digit",
-                                            minute: "2-digit"
-                                        });
-
-                                        kimiDiv.appendChild(kimiMessageDiv);
-                                        kimiDiv.appendChild(kimiTimeDiv);
-                                        chatMessages.appendChild(kimiDiv);
-                                        chatMessages.scrollTop = chatMessages.scrollHeight;
-                                    }
-                                }
-                                setTimeout(() => {
-                                    this.speak(response);
-                                }, 500);
-                            }
-                        } else {
-                            const response = await this.onSpeechAnalysis(final_transcript);
-                            if (response) {
-                                const chatContainer = document.getElementById("chat-container");
-                                const chatMessages = document.getElementById("chat-messages");
-                                if (chatContainer && chatContainer.classList.contains("visible") && chatMessages) {
-                                    const addMessageToChat =
-                                        window.addMessageToChat ||
-                                        (typeof addMessageToChat !== "undefined" ? addMessageToChat : null);
-                                    if (addMessageToChat) {
-                                        addMessageToChat("user", final_transcript);
-                                        addMessageToChat("kimi", response);
-                                    } else {
-                                        const userDiv = document.createElement("div");
-                                        userDiv.className = "message user";
-
-                                        const userMessageDiv = document.createElement("div");
-                                        userMessageDiv.textContent = final_transcript;
-
-                                        const userTimeDiv = document.createElement("div");
-                                        userTimeDiv.className = "message-time";
-                                        userTimeDiv.textContent = new Date().toLocaleTimeString("en-US", {
-                                            hour: "2-digit",
-                                            minute: "2-digit"
-                                        });
-
-                                        userDiv.appendChild(userMessageDiv);
-                                        userDiv.appendChild(userTimeDiv);
-                                        chatMessages.appendChild(userDiv);
-
-                                        const kimiDiv = document.createElement("div");
-                                        kimiDiv.className = "message kimi";
-
-                                        const kimiMessageDiv = document.createElement("div");
-                                        kimiMessageDiv.textContent = response;
-
-                                        const kimiTimeDiv = document.createElement("div");
-                                        kimiTimeDiv.className = "message-time";
-                                        kimiTimeDiv.textContent = new Date().toLocaleTimeString("en-US", {
-                                            hour: "2-digit",
-                                            minute: "2-digit"
-                                        });
-
-                                        kimiDiv.appendChild(kimiMessageDiv);
-                                        kimiDiv.appendChild(kimiTimeDiv);
-                                        chatMessages.appendChild(kimiDiv);
-                                        chatMessages.scrollTop = chatMessages.scrollHeight;
-                                    }
-                                }
-                                setTimeout(() => {
-                                    this.speak(response);
-                                }, 500);
-                            }
+                            response = await window.analyzeAndReact(final_transcript);
+                        } else if (this.onSpeechAnalysis) {
+                            response = await this.onSpeechAnalysis(final_transcript);
+                        }
+
+                        if (response) {
+                            this.handleChatMessage(final_transcript, response);
+                            setTimeout(() => {
+                                this.speak(response);
+                            }, 500);
                         }
                     })();
                 } catch (error) {
@@ -829,7 +955,6 @@ class KimiVoiceManager {
 
         // Add the event listener
         this.micButton.addEventListener("click", this.handleMicClick);
-        console.log("🎤 Microphone button event listener setup complete");
     }
 
     async startListening() {
@@ -1011,11 +1136,11 @@ class KimiVoiceManager {
 
     // ===== UTILITY METHODS =====
     isVoiceAvailable() {
-        return this.kimiFrenchVoice !== null;
+        return this.currentVoice !== null;
     }
 
     getCurrentVoice() {
-        return this.kimiFrenchVoice;
+        return this.currentVoice;
     }
 
     getAvailableVoices() {
@@ -1081,10 +1206,31 @@ class KimiVoiceManager {
             this.speechSynthesis.cancel();
         }
 
+        // Clean up mic button event listener
         if (this.micButton && this.handleMicClick) {
             this.micButton.removeEventListener("click", this.handleMicClick);
         }
 
+        // Clean up voice selector event listener
+        if (this.voiceChangeHandler) {
+            const voiceSelect = document.getElementById("voice-selection");
+            if (voiceSelect) {
+                voiceSelect.removeEventListener("change", this.voiceChangeHandler);
+            }
+            this.voiceChangeHandler = null;
+        }
+
+        // Clean up language selector event listener
+        if (this.languageChangeHandler) {
+            const languageSelect = document.getElementById("language-selection");
+            if (languageSelect) {
+                languageSelect.removeEventListener("change", this.languageChangeHandler);
+            }
+            this.languageChangeHandler = null;
+        }
+
+        // Reset state
+        this.currentVoice = null;
         this.isInitialized = false;
         this.isListening = false;
         this.isStoppingVolontaire = false;
@@ -1096,47 +1242,65 @@ class KimiVoiceManager {
     setupLanguageSelector() {
         const languageSelect = document.getElementById("language-selection");
         if (!languageSelect) return;
+
         languageSelect.value = this.selectedLanguage || "en";
+
+        // Remove existing handler before adding new one
+        if (this.languageChangeHandler) {
+            languageSelect.removeEventListener("change", this.languageChangeHandler);
+        }
+
+        // Create and store the handler
+        this.languageChangeHandler = this.handleLanguageChange.bind(this);
+        languageSelect.addEventListener("change", this.languageChangeHandler);
     }
 
     async handleLanguageChange(e) {
         const newLang = e.target.value;
-        console.log(`🎤 Language changing to: ${newLang}`);
+        const oldLang = this.selectedLanguage;
+        console.log(`� Language changing: "${oldLang}" → "${newLang}"`);
+
         this.selectedLanguage = newLang;
         await this.db?.setPreference("selectedLanguage", newLang);
 
-        // Force voice reset when changing language
-        const currentVoicePref = await this.db?.getPreference("selectedVoice", "auto");
-        if (currentVoicePref === "auto") {
-            // Reset voice selection to force auto-selection for new language
-            this.kimiEnglishVoice = null;
-            console.log(`🎤 Voice reset for auto-selection in ${newLang}`);
+        // Update i18n system for interface translations
+        if (window.kimiI18nManager?.setLanguage) {
+            await window.kimiI18nManager.setLanguage(newLang);
         }
 
+        // ALWAYS reset voice when changing language to ensure compatibility
+        const currentVoicePref = await this.db?.getPreference("selectedVoice", "auto");
+
+        // Reset voice selection to force re-selection for new language
+        this.currentVoice = null;
+
+        // CRITICAL: Reset voice preference to "auto" to prevent old voice from being reused
+        await this.db?.setPreference("selectedVoice", "auto");
+
         await this.initVoices();
-        console.log(
-            `🎤 Voice initialized for ${newLang}, selected voice:`,
-            this.kimiEnglishVoice?.name,
-            this.kimiEnglishVoice?.lang
-        );
+
+        if (this.currentVoice) {
+            console.log(`🎤 Voice selected for "${newLang}": "${this.currentVoice.name}" (${this.currentVoice.lang})`);
+        } else {
+            console.warn(`🎤 No voice found for language "${newLang}"`);
+        }
 
         if (this.recognition) {
-            let langCode = newLang;
-            if (langCode === "fr") langCode = "fr-FR";
-            else if (langCode === "en") langCode = "en-US";
-            else if (langCode === "es") langCode = "es-ES";
-            else if (langCode === "de") langCode = "de-DE";
-            else if (langCode === "it") langCode = "it-IT";
-            else if (langCode === "ja") langCode = "ja-JP";
-            else if (langCode === "zh") langCode = "zh-CN";
+            const langCode = this.getLanguageCode(newLang);
             this.recognition.lang = langCode;
         }
     }
 
     async updateSelectedCharacter() {
         if (this.db && typeof this.db.getSelectedCharacter === "function") {
-            const char = await this.db.getSelectedCharacter();
-            if (char) this.selectedCharacter = char;
+            const charKey = await this.db.getSelectedCharacter();
+            if (charKey && window.KIMI_CHARACTERS && window.KIMI_CHARACTERS[charKey]) {
+                // Use the display name, not the key
+                this.selectedCharacter = window.KIMI_CHARACTERS[charKey].name;
+            } else if (charKey) {
+                // Fallback to key if KIMI_CHARACTERS not available
+                this.selectedCharacter = charKey;
+            }
         }
     }
 

kimi-locale/de.json

@@ -139,7 +139,6 @@
     "storage_used": "Speicher verwendet",
     "saved": "Gespeichert!",
     "saved_short": "Gespeichert",
-    "api_key_help_title": "Gespeichert = Ihr API-Schlüssel ist für diesen Anbieter gespeichert. Verwenden Sie ‘Test API Key’, um die Verbindung zu prüfen.",
     "reset_done": "Zurückgesetzt!",
     "category_listening": "Zuhören",
     "category_dancing": "Tanzen",

kimi-locale/en.json

@@ -139,7 +139,6 @@
     "storage_used": "Storage used",
     "saved": "Saved!",
     "saved_short": "Saved",
-    "api_key_help_title": "Saved = your API key is stored for this provider. Use Test API Key to verify the connection.",
     "reset_done": "Reset!",
     "category_listening": "Listening",
     "category_dancing": "Dancing",

kimi-locale/es.json

@@ -139,7 +139,6 @@
     "storage_used": "Almacenamiento usado",
     "saved": "¡Guardado!",
     "saved_short": "Guardado",
-    "api_key_help_title": "Guardado = tu clave API está almacenada para este proveedor. Usa 'Test API Key' para verificar la conexión.",
     "reset_done": "¡Restaurado!",
     "category_listening": "Escuchando",
     "category_dancing": "Bailando",

kimi-locale/fr.json

@@ -139,7 +139,6 @@
     "storage_used": "Stockage utilisé",
     "saved": "Sauvegardé !",
     "saved_short": "Sauvegardé",
-    "api_key_help_title": "Sauvegardé = votre clé API est stockée pour ce provider. Utilisez ‘Test API Key’ pour vérifier la connexion.",
     "reset_done": "Réinitialisé !",
     "category_listening": "À l'écoute",
     "category_dancing": "En train de danser",

kimi-locale/it.json

@@ -139,7 +139,6 @@
     "storage_used": "Spazio utilizzato",
     "saved": "Salvato!",
     "saved_short": "Salvato",
-    "api_key_help_title": "Saved = your API key is stored for this provider. Use ‘Test API Key’ to verify the connection.",
     "reset_done": "Ripristinato!",
     "category_listening": "Ascoltando",
     "category_dancing": "Ballando",

kimi-locale/ja.json

@@ -139,7 +139,6 @@
     "storage_used": "使用ストレージ",
     "saved": "保存されました！",
     "saved_short": "保存",
-    "api_key_help_title": "保存 = このプロバイダー用のAPIキーが保存されました。接続確認には『Test API Key』を使用してください。",
     "reset_done": "リセット完了！",
     "category_listening": "聞いている",
     "category_dancing": "踊っている",

kimi-locale/zh.json

@@ -139,7 +139,6 @@
     "storage_used": "已使用存储",
     "saved": "已保存！",
     "saved_short": "已保存",
-    "api_key_help_title": "已保存 = 您的API密钥已为该提供商保存。使用“Test API Key”验证连接。",
     "reset_done": "重置完成！",
     "category_listening": "聆听",
     "category_dancing": "跳舞",