fix: resolve menu bar updates and AI enhancement issues

- Add immediate tray menu updates when model selection changes
- Fix default enhancement prompt to preserve natural speech format
- Add error feedback in recording pill when enhancement fails
- Implement event-driven API key removal with proper UI state sync
- Remove duplicate state updates and cache clearing calls
- Fix backend validation to allow empty provider for deselection

These changes ensure proper state synchronization across the app using
event-driven architecture, consistent with existing patterns in SettingsContext.

Author: moinulmoin

src-tauri/src/ai/prompts.rs

@@ -83,66 +83,67 @@ pub fn build_enhancement_prompt(
     prompt
 }
 
-const DEFAULT_PROMPT: &str = r#"THEN clean up this voice transcription to create professional, readable text while preserving the speaker's intended meaning.
+const DEFAULT_PROMPT: &str = r#"THEN clean up this voice transcription like a high-quality dictation tool would - fix errors while keeping the natural speech flow.
 
 APPLY THESE CORRECTIONS:
 
 1. REMOVE speech artifacts:
-   - Filler words: um, uh, ah, er, hmm, like (when filler), you know (when filler), basically (when redundant), actually (when redundant)
+   - Filler words: um, uh, ah, er, hmm, like (when filler), you know (when filler)
    - False starts and incomplete thoughts
    - Unintentional word repetitions and stutters: "I I think", "that that's"
    - Verbal backspacing: "wait", "scratch that", "let me rephrase"
 
 2. FIX common errors:
-   - Homophones: there/their/they're, to/too/two, your/you're, its/it's, then/than, here/hear, write/right
+   - Homophones: there/their/they're, to/too/two, your/you're, its/it's, then/than
    - Grammar: subject-verb agreement, article usage (a/an/the)
-   - Technical terms: "java script" → "JavaScript", "type script" → "TypeScript", "react js" → "React.js"
+   - Technical terms (fix misheard/misspelled tech words):
+     * "java script" → "JavaScript", "type script" → "TypeScript", "react js" → "React.js"
+     * "fortend/frontent/front and" → "frontend"
+     * "backing/back and/beck end" → "backend"
+     * "jason/jayson" → "JSON", "A P I" → "API"
+     * Common programming terms that sound similar
    - Contractions: "dont" → "don't", "wont" → "won't", "cant" → "can't"
    - Word boundaries: "alot" → "a lot", "incase" → "in case"
 
-3. FORMAT properly:
+3. ADD proper formatting:
    - Capitalize sentence beginnings and proper nouns (names, places, brands)
    - Add punctuation based on speech patterns and context
    - Numbers: "twenty twenty five" → "2025", "one hundred" → "100"
-   - Times: "two thirty PM" → "2:30 PM", "three o'clock" → "3:00"
-   - Dates: "january first" → "January 1st", "the fifth of march" → "March 5th"
+   - Times: "two thirty PM" → "2:30 PM"
+   - Dates: "january first" → "January 1st"
    - Split run-on sentences at natural break points
-   - Format lists when detected: "first... second..." → "1) ... 2) ..."
 
-4. HANDLE spoken punctuation (when clearly commands):
-   - "comma" → , (when spoken as command)
-   - "period" or "full stop" → .
+4. HANDLE explicit dictation commands:
+   - "period" or "full stop" → . (only when clearly dictating)
+   - "comma" → , (only when clearly dictating)
    - "question mark" → ?
-   - "exclamation point" → !
-   - "quote/unquote" → "..."
-   - "open/close parenthesis" → ()
-   - "colon" → :
-   - "semicolon" → ;
-
-5. PRESERVE:
-   - Technical jargon and domain-specific terms
-   - Intentional emphasis through repetition
-   - Natural conversational tone
-   - Quoted speech or dialogue
-   - Acronyms spoken as letters (FBI, API, URL)
+   - "new paragraph" → create paragraph break
+   - Email addresses: "john at gmail dot com" → "john@gmail.com"
+
+5. KEEP the natural flow:
+   - Don't restructure into lists or bullet points
+   - Keep the conversational sequence intact
+   - Preserve the speaker's tone and style
+   - Don't make casual speech overly formal
+   - Maintain original sentence connections
 
 EXAMPLES:
-"um their going too the store at two thirty PM comma and there buying to apples period" 
-→ "They're going to the store at 2:30 PM, and they're buying two apples."
+"um their going too the store at two thirty PM and there buying to apples" 
+→ "They're going to the store at 2:30 PM and they're buying two apples."
 
 "the java script function returns uh jason data with a two hundred status"
 → "The JavaScript function returns JSON data with a 200 status."
 
 "first we need milk second bread third eggs"
-→ "First, we need: 1) milk, 2) bread, 3) eggs."
+→ "First, we need milk, second bread, third eggs."
 
-"can you send it to john at gmail dot com question mark"
+"can you send it to john at gmail dot com"
 → "Can you send it to john@gmail.com?"
 
 "I I think that that's the last no wait the least important one"
 → "I think that's the least important one."
 
-Return ONLY the cleaned text."#;
+Return ONLY the cleaned text as natural dictation output."#;
 
 // Thin transformation layer for Prompts preset
 const PROMPTS_TRANSFORM: &str = r#"FINALLY, transform the cleaned text into a well-structured AI prompt:

src-tauri/src/commands/ai.rs

@@ -257,14 +257,19 @@ pub async fn clear_ai_api_key_cache(
     _app: tauri::AppHandle,
     provider: String,
 ) -> Result<(), String> {
-    validate_provider_name(&provider)?;
+    // Skip validation if provider is empty (happens when clearing selection)
+    if !provider.is_empty() {
+        validate_provider_name(&provider)?;
+    }
 
     let mut cache = API_KEY_CACHE
         .lock()
         .map_err(|_| "Failed to access cache".to_string())?;
-    cache.remove(&format!("ai_api_key_{}", provider));
-
-    log::info!("API key cache cleared for provider: {}", provider);
+    
+    if !provider.is_empty() {
+        cache.remove(&format!("ai_api_key_{}", provider));
+        log::info!("API key cache cleared for provider: {}", provider);
+    }
 
     Ok(())
 }
@@ -286,7 +291,10 @@ pub async fn update_ai_settings(
     model: String,
     app: tauri::AppHandle,
 ) -> Result<(), String> {
-    validate_provider_name(&provider)?;
+    // Allow empty provider and model for deselection
+    if !provider.is_empty() {
+        validate_provider_name(&provider)?;
+    }
 
     // Allow empty model (for deselection) but validate if not empty
     if !model.is_empty() {

src-tauri/src/commands/audio.rs

@@ -1013,40 +1013,37 @@ pub async fn stop_recording(
                                     enhanced
                                 }
                                 Err(e) => {
-                                    // Emit enhancing failed event
+                                    log::warn!("AI enhancement failed, using original text: {}", e);
+
+                                    // Check error type and create appropriate message
+                                    let error_message = e.to_string();
+                                    let user_message = if error_message.contains("400") || error_message.contains("Bad Request") {
+                                        "Enhancement failed: Missing or invalid API key"
+                                    } else if error_message.contains("401") || error_message.contains("Unauthorized") {
+                                        "Enhancement failed: Invalid API key"
+                                    } else if error_message.contains("429") {
+                                        "Enhancement failed: Rate limit exceeded"
+                                    } else if error_message.contains("network") || error_message.contains("connection") {
+                                        "Enhancement failed: Network error"
+                                    } else {
+                                        "Enhancement failed: Using original text"
+                                    };
+
+                                    // Emit enhancing failed event with error message to pill
                                     let _ = emit_to_window(
                                         &app_for_process,
                                         "pill",
                                         "enhancing-failed",
-                                        (),
+                                        user_message,
                                     );
-                                    log::warn!("AI enhancement failed, using original text: {}", e);
 
-                                    // Check if it's an authentication error and notify frontend
-                                    let error_message = e.to_string();
-                                    if error_message.contains("401")
-                                        || error_message.contains("Unauthorized")
-                                    {
+                                    // Also notify main window for settings update if needed
+                                    if error_message.contains("400") || error_message.contains("401") || error_message.contains("Bad Request") || error_message.contains("Unauthorized") {
                                         let _ = emit_to_window(
                                             &app_for_process,
                                             "main",
                                             "ai-enhancement-auth-error",
-                                            "Invalid API key. Please check your AI settings.",
-                                        );
-                                    } else if error_message.contains("429") {
-                                        let _ = emit_to_window(
-                                            &app_for_process,
-                                            "main",
-                                            "ai-enhancement-error",
-                                            "Rate limit exceeded. Please try again later.",
-                                        );
-                                    } else {
-                                        // Generic enhancement error
-                                        let _ = emit_to_window(
-                                            &app_for_process,
-                                            "main",
-                                            "ai-enhancement-error",
-                                            "AI enhancement failed. Using original text.",
+                                            "Please check your AI API key in settings.",
                                         );
                                     }
 

src-tauri/src/commands/settings.rs

@@ -145,17 +145,18 @@ pub async fn save_settings(app: AppHandle, settings: Settings) -> Result<(), Str
 
     store.save().map_err(|e| e.to_string())?;
 
-    // Preload new model if it changed
+    // Preload new model and update tray menu if model changed
     if !settings.current_model.is_empty() && old_model != settings.current_model {
         use crate::commands::model::preload_model;
         use tauri::async_runtime::RwLock as AsyncRwLock;
 
         log::info!(
-            "Model changed from '{}' to '{}', preloading new model",
+            "Model changed from '{}' to '{}', preloading new model and updating tray menu",
             old_model,
             settings.current_model
         );
 
+        // Preload the new model
         let app_clone = app.clone();
         let model_name = settings.current_model.clone();
         tokio::spawn(async move {
@@ -166,6 +167,12 @@ pub async fn save_settings(app: AppHandle, settings: Settings) -> Result<(), Str
                 Err(e) => log::warn!("Failed to preload new model: {}", e),
             }
         });
+        
+        // Update the tray menu to reflect the new selection
+        if let Err(e) = update_tray_menu(app.clone()).await {
+            log::warn!("Failed to update tray menu after model change: {}", e);
+            // Don't fail the whole operation if tray update fails
+        }
     }
 
     Ok(())

src/components/RecordingPill.tsx

@@ -156,9 +156,11 @@ export function RecordingPill() {
     );
 
     unlisteners.push(
-      listen("enhancing-failed", () => {
-        console.log("RecordingPill: Received enhancing-failed event");
+      listen<string>("enhancing-failed", (event) => {
+        console.log("RecordingPill: Received enhancing-failed event", event.payload);
         setIsEnhancing(false);
+        // Show error message for 4 seconds
+        setFeedbackWithTimeout(event.payload || "Enhancement failed", 4000);
       })
     );
 

src/components/sections/EnhancementsSection.tsx

@@ -187,8 +187,41 @@ export function EnhancementsSection() {
       }
     });
 
+    // Listen for API key remove events
+    const unlistenApiKeyRemoved = listen<{ provider: string }>('api-key-removed', async (event) => {
+      console.log('[AI Settings] API key removed for provider:', event.payload.provider);
+      
+      // Update local state immediately
+      setProviderApiKeys(prev => ({ ...prev, [event.payload.provider]: false }));
+      
+      // Check if the removed key was for the currently selected model
+      const selectedModel = models.find(m => m.id === aiSettings.model);
+      if (selectedModel && selectedModel.provider === event.payload.provider) {
+        console.log('[AI Settings] Clearing model selection for removed API key');
+        // Clear the model selection and disable AI
+        setAISettings(prev => ({
+          ...prev,
+          enabled: false,
+          provider: "",
+          model: "",
+          hasApiKey: false
+        }));
+        
+        // Update backend to clear the selection
+        try {
+          await invoke("update_ai_settings", {
+            enabled: false,
+            provider: "",
+            model: ""
+          });
+        } catch (error) {
+          console.error('Failed to update backend settings:', error);
+        }
+      }
+    });
+
     return () => {
-      Promise.all([unlistenReady, unlistenApiKey]).then(fns => {
+      Promise.all([unlistenReady, unlistenApiKey, unlistenApiKeyRemoved]).then(fns => {
         fns.forEach(fn => fn());
       });
     };
@@ -275,21 +308,11 @@ export function EnhancementsSection() {
   const handleRemoveApiKey = async (provider: string) => {
     try {
       console.log(`[AI Settings] Removing API key for provider: ${provider}`);
+      
+      // Remove the key (this also clears backend cache and emits the event)
+      // The 'api-key-removed' event listener will handle all UI updates
       await removeApiKey(provider);
-
-      // If the removed key was for the currently selected model, deselect it
-      const selectedModel = models.find(m => m.id === aiSettings.model);
-      if (selectedModel && selectedModel.provider === provider) {
-        console.log(`[AI Settings] Deselecting model ${selectedModel.id} due to API key removal`);
-        // Deselect model and disable AI enhancement
-        await invoke("update_ai_settings", {
-          enabled: false,
-          provider: aiSettings.provider,
-          model: ""  // Clear model selection
-        });
-      }
-
-      await loadAISettings();
+      
       toast.success("API key removed");
     } catch (error) {
       console.error(`[AI Settings] Failed to remove API key:`, error);
@@ -332,7 +355,7 @@ export function EnhancementsSection() {
                 key={model.id}
                 model={model}
                 hasApiKey={providerApiKeys[model.provider] || false}
-                isSelected={aiSettings.model === model.id}
+                isSelected={aiSettings.model === model.id && providerApiKeys[model.provider]}
                 onSetupApiKey={() => handleSetupApiKey(model.provider)}
                 onSelect={() => handleModelSelect(model.id, model.provider)}
                 onRemoveApiKey={() => handleRemoveApiKey(model.provider)}

src/components/tabs/ModelsTab.tsx

@@ -31,17 +31,17 @@ export function ModelsTab() {
 
       // If deleted model was the current one, clear selection in settings
       if (settings?.current_model === modelName) {
-        await saveSettings({ ...settings, current_model: "" });
+        await saveSettings({ current_model: "" });
       }
     },
     [deleteModel, settings]
   );
 
   // Save settings
   const saveSettings = useCallback(
-    async (newSettings: AppSettings) => {
+    async (updates: Partial<AppSettings>) => {
       try {
-        await updateSettings(newSettings);
+        await updateSettings(updates);
       } catch (error) {
         console.error("Failed to save settings:", error);
       }
@@ -88,7 +88,7 @@ export function ModelsTab() {
       onCancelDownload={cancelDownload}
       onSelect={async (modelName) => {
         if (settings) {
-          await saveSettings({ ...settings, current_model: modelName });
+          await saveSettings({ current_model: modelName });
         }
       }}
     />

src/utils/keyring.ts

@@ -68,6 +68,9 @@ export const removeApiKey = async (provider: string): Promise<void> => {
   await invoke('clear_ai_api_key_cache', { provider });
 
   console.log(`[Keyring] API key removed for ${provider}`);
+  
+  // Emit event to notify that API key was removed
+  await emit('api-key-removed', { provider });
 };
 
 // Load all API keys to backend cache (for app startup)