Merge pull request #164 from jhult/fix/ui-updates

Clean up UI metadata, error modal, and free model cost display

Author: Kuberwastaken

src-rust/crates/api/src/model_registry.rs

@@ -449,10 +449,21 @@ fn parse_snapshot_str(s: &str) -> Option<ParsedSnapshot> {
     parse_snapshot_bytes(s.as_bytes())
 }
 
+// models.dev uses "opencode" as the top-level key, but our provider config and
+// free-model detection expect "opencode-zen". Remap at parse time so a snapshot
+// refresh never silently breaks free-model detection again.
+fn remap_provider_id(id: &str) -> &str {
+    match id {
+        "opencode" => "opencode-zen",
+        other => other,
+    }
+}
+
 fn transform_api(api: md::ApiJson) -> ParsedSnapshot {
     let mut out = ParsedSnapshot::default();
 
-    for (provider_id, p) in api.into_iter() {
+    for (raw_provider_id, p) in api.into_iter() {
+        let provider_id = remap_provider_id(&raw_provider_id).to_string();
         let pid = ProviderId::new(provider_id.clone());
 
         out.providers.insert(provider_id.clone(), ProviderEntry {
@@ -1173,4 +1184,24 @@ mod tests {
         assert_eq!(anthropic.name, "Anthropic");
         assert!(anthropic.env.iter().any(|e| e == "ANTHROPIC_API_KEY"));
     }
+
+    #[test]
+    fn opencode_remapped_to_opencode_zen() {
+        // models.dev uses "opencode" as the top-level key; we must normalize it
+        // to "opencode-zen" so free-model detection works correctly.
+        let json = r#"{"opencode":{"id":"opencode","name":"OpenCode Zen","env":[],"models":{"qwen3.6-plus-free":{"id":"qwen3.6-plus-free","name":"Qwen 3.6 Plus Free","cost":{"input":0,"output":0},"limit":{"context":8192,"output":4096}}}}}"#;
+        let parsed = parse_snapshot_str(json).expect("parse must succeed");
+        assert!(
+            parsed.providers.contains_key("opencode-zen"),
+            "provider must be stored as opencode-zen"
+        );
+        assert!(
+            !parsed.providers.contains_key("opencode"),
+            "raw opencode key must not appear in registry"
+        );
+        assert!(
+            parsed.models.contains_key("opencode-zen/qwen3.6-plus-free"),
+            "model key must use opencode-zen prefix"
+        );
+    }
 }

src-rust/crates/cli/src/main.rs

@@ -445,7 +445,10 @@ async fn main() -> anyhow::Result<()> {
     let base_filter = EnvFilter::try_from_default_env()
         .unwrap_or_else(|_| EnvFilter::new(log_level));
     let log_filter = base_filter
-        .add_directive("rmcp::service::client=error".parse().expect("valid rmcp directive"));
+        .add_directive("rmcp::service::client=error".parse().expect("valid rmcp directive"))
+        // Suppress error/warn logs from providers and query — errors are already shown as error modals
+        .add_directive("claurst_api::providers::free=off".parse().expect("valid directive"))
+        .add_directive("claurst_query=off".parse().expect("valid directive"));
     tracing_subscriber::fmt()
         .with_env_filter(log_filter)
         .with_target(false)
@@ -2008,38 +2011,7 @@ async fn run_interactive(
 
                     // Enter => submit input (but NOT when ANY dialog/overlay is open —
                     // dialogs handle their own Enter in handle_key_event).
-                    let any_dialog_open = app.connect_dialog.visible
-                        || app.import_config_picker.visible
-                        || app.import_config_dialog.visible
-                        || app.key_input_dialog.visible
-                        || app.custom_provider_dialog.visible
-                        || app.device_auth_dialog.visible
-                        || app.command_palette.visible
-                        || app.model_picker.visible
-                        || app.onboarding_dialog.visible
-                        || app.bypass_permissions_dialog.visible
-                        || app.file_injection_dialog.visible
-                        || app.ask_user_dialog.visible
-                        || app.settings_screen.visible
-                        || app.export_dialog.visible
-                        || app.theme_screen.visible
-                        || app.stats_dialog.open
-                        || app.invalid_config_dialog.visible
-                        || app.context_viz.visible
-                        || app.mcp_approval.visible
-                        || app.session_browser.visible
-                        || app.session_branching.visible
-                        || app.tasks_overlay.visible
-                        || app.mcp_view.open
-                        || app.agents_menu.open
-                        || app.diff_viewer.open
-                        || app.help_overlay.visible
-                        || app.history_search_overlay.visible
-                        || app.rewind_flow.visible
-                        || app.show_help
-                        || app.context_menu_state.is_some()
-                        || app.permission_request.is_some()
-                        || app.global_search.open;
+                    let any_dialog_open = app.any_modal_open();
                     if key.code == KeyCode::Enter && app.is_streaming && !any_dialog_open {
                         // Queue the message: it will auto-submit once the
                         // current turn finishes (issue #149).
@@ -3523,8 +3495,17 @@ async fn run_interactive(
 
         if task_finished {
             if let Some((handle, msgs_arc)) = current_query.take() {
-                // Get the outcome (ignore errors for now)
-                let _ = handle.await;
+                // Get the outcome and handle errors
+                if let Ok(QueryOutcome::Error(err)) = handle.await {
+                    while app.notifications.current_is_error() {
+                        app.notifications.dismiss_current();
+                    }
+                    app.notifications.push(
+                        claurst_tui::notifications::NotificationKind::Error,
+                        err.to_string(),
+                        None,
+                    );
+                }
                 // Sync the updated conversation back to our local vector
                 messages = msgs_arc.lock().await.clone();
                 session.messages = messages.clone();
@@ -3738,7 +3719,7 @@ async fn run_interactive(
             tool_ctx.mcp_manager = new_mcp_manager.clone();
             app.mcp_manager = new_mcp_manager.clone();
             tools_arc = build_tools_with_mcp(new_mcp_manager.clone());
-            if app.mcp_view.open {
+            if app.mcp_view.visible {
                 app.refresh_mcp_view();
             }
 

src-rust/crates/core/src/lib.rs

@@ -34,6 +34,8 @@ pub mod format_utils;
 pub mod crypto_utils;
 pub mod status_notices;
 pub mod auto_mode;
+pub mod spinner;
+pub use spinner::{SPINNER_VERBS, TURN_COMPLETION_VERBS, sample_spinner_verb, sample_completion_verb};
 
 // Remote session sync and cloud session API (T3-1, T3-2).
 pub mod remote_session;
@@ -1277,7 +1279,6 @@ pub mod config {
         }
 
 
-
         /// Resolve the effective max-tokens.
         pub fn effective_max_tokens(&self) -> u32 {
             self.max_tokens
@@ -3215,8 +3216,36 @@ pub mod cost {
     use std::sync::atomic::{AtomicU64, Ordering};
     use std::sync::Arc;
 
+    /// Free upstream provider IDs used in the free provider system.
+    ///
+    /// These overlap with providers that appear in `api_key_env_vars_for_provider`.
+    /// When adding a provider to one, check whether it also belongs in the other.
+    const FREE_UPSTREAM_IDS: &[&str] = &[
+        "groq",
+        "cerebras",
+        "google",
+        "mistral",
+        "sambanova",
+        "nvidia",
+        "cohere",
+        "openrouter",
+        "opencode-zen",
+        "zai",
+        "zhipuai",
+    ];
+
+    /// Check if a model name is an upstream-prefixed free model (e.g., "groq/llama-3.3-70b-versatile").
+    fn is_free_upstream_model(model: &str) -> bool {
+        for upstream_id in FREE_UPSTREAM_IDS {
+            if model.starts_with(&format!("{}/", upstream_id)) {
+                return true;
+            }
+        }
+        false
+    }
+
     /// Per-model pricing tiers (USD per million tokens).
-    #[derive(Debug, Clone, Copy)]
+    #[derive(Debug, Clone, Copy, PartialEq)]
     pub struct ModelPricing {
         pub input_per_mtk: f64,
         pub output_per_mtk: f64,
@@ -3249,14 +3278,27 @@ pub mod cost {
             cache_read_per_mtk: 0.08,
         };
 
+        /// Free model pricing (no cost).
+        pub const FREE: Self = Self {
+            input_per_mtk: 0.0,
+            output_per_mtk: 0.0,
+            cache_creation_per_mtk: 0.0,
+            cache_read_per_mtk: 0.0,
+        };
+
         /// Default pricing is Opus (most capable, highest cost).
         pub fn default_pricing() -> Self {
             Self::OPUS
         }
 
         /// Pick pricing based on model name substring matching.
         pub fn for_model(model: &str) -> Self {
-            if model.contains("opus") {
+            // Check for free models first (those with "-free" suffix, "free/" prefix, or upstream-prefixed free model)
+            if model.ends_with("-free") || model.starts_with("free/") {
+                Self::FREE
+            } else if is_free_upstream_model(model) {
+                Self::FREE
+            } else if model.contains("opus") {
                 Self::OPUS
             } else if model.contains("haiku") {
                 Self::HAIKU
@@ -3359,7 +3401,9 @@ pub mod cost {
         pub fn summary(&self) -> String {
             let cost = self.total_cost_usd();
             let total = self.total_tokens();
-            if cost < 0.01 {
+            if cost == 0.0 {
+                format!("{} tokens ($0.00)", total)
+            } else if cost < 0.01 {
                 format!("{} tokens (<$0.01)", total)
             } else {
                 format!("{} tokens (${:.2})", total, cost)
@@ -4343,6 +4387,43 @@ mod tests {
         assert_eq!(tracker.total_cost_usd(), 0.0);
     }
 
+    #[test]
+    fn test_cost_tracker_free_model() {
+        let tracker = CostTracker::with_model("deepseek-v4-flash-free");
+        tracker.add_usage(1000, 500, 200, 100);
+        // Free models should have zero cost even with token usage
+        assert_eq!(tracker.total_cost_usd(), 0.0);
+    }
+
+    #[test]
+    fn test_model_pricing_free_variants() {
+        // Test that models ending with -free use FREE pricing
+        assert_eq!(cost::ModelPricing::for_model("deepseek-v4-flash-free"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("zen/minimax-m2.5-free"), cost::ModelPricing::FREE);
+
+        // Test that models starting with free/ use FREE pricing
+        assert_eq!(cost::ModelPricing::for_model("free/auto"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("free/some-model"), cost::ModelPricing::FREE);
+
+        // Test that upstream-prefixed free models use FREE pricing
+        assert_eq!(cost::ModelPricing::for_model("groq/llama-3.3-70b-versatile"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("cerebras/qwen-3-235b-a22b-instruct-2507"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("google/gemini-2.5-flash"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("mistral/mistral-large-latest"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("sambanova/Meta-Llama-3.3-70B-Instruct"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("nvidia/meta/llama-3.3-70b-instruct"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("cohere/command-r-plus"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("openrouter/free"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("opencode-zen/minimax-m2.5-free"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("zai/glm-4.6"), cost::ModelPricing::FREE);
+        assert_eq!(cost::ModelPricing::for_model("zhipuai/glm-4.5"), cost::ModelPricing::FREE);
+
+        // Test that other models use their appropriate pricing
+        assert_eq!(cost::ModelPricing::for_model("claude-opus"), cost::ModelPricing::OPUS);
+        assert_eq!(cost::ModelPricing::for_model("claude-haiku"), cost::ModelPricing::HAIKU);
+        assert_eq!(cost::ModelPricing::for_model("claude-sonnet"), cost::ModelPricing::SONNET);
+    }
+
     #[test]
     fn managed_agent_config_serde_round_trip() {
         let cfg = ManagedAgentConfig {

src-rust/crates/core/src/spinner.rs

@@ -0,0 +1,51 @@
+/// Spinner verbs displayed during processing.
+pub const SPINNER_VERBS: &[&str] = &[
+    "Accomplishing", "Actioning", "Actualizing", "Architecting", "Baking", "Beaming",
+    "Beboppin'", "Befuddling", "Billowing", "Blanching", "Bloviating", "Boogieing",
+    "Boondoggling", "Booping", "Bootstrapping", "Brewing", "Bunning", "Burrowing",
+    "Calculating", "Canoodling", "Caramelizing", "Cascading", "Catapulting", "Cerebrating",
+    "Channeling", "Choreographing", "Churning", "Clauding", "Coalescing", "Cogitating",
+    "Combobulating", "Composing", "Computing", "Concocting", "Considering", "Contemplating",
+    "Cooking", "Crafting", "Creating", "Crunching", "Crystallizing", "Cultivating",
+    "Deciphering", "Deliberating", "Determining", "Dilly-dallying", "Discombobulating",
+    "Doing", "Doodling", "Drizzling", "Ebbing", "Effecting", "Elucidating", "Embellishing",
+    "Enchanting", "Envisioning", "Evaporating", "Fermenting", "Fiddle-faddling", "Finagling",
+    "Flambéing", "Flibbertigibbeting", "Flowing", "Flummoxing", "Fluttering", "Forging",
+    "Forming", "Frolicking", "Frosting", "Gallivanting", "Galloping", "Garnishing",
+    "Generating", "Gesticulating", "Germinating", "Gitifying", "Grooving", "Gusting",
+    "Harmonizing", "Hashing", "Hatching", "Herding", "Honking", "Hullaballooing",
+    "Hyperspacing", "Ideating", "Imagining", "Improvising", "Incubating", "Inferring",
+    "Infusing", "Ionizing", "Jitterbugging", "Julienning", "Kneading", "Leavening",
+    "Levitating", "Lollygagging", "Manifesting", "Marinating", "Meandering", "Metamorphosing",
+    "Misting", "Moonwalking", "Moseying", "Mulling", "Mustering", "Musing", "Nebulizing",
+    "Nesting", "Newspapering", "Noodling", "Nucleating", "Orbiting", "Orchestrating",
+    "Osmosing", "Perambulating", "Percolating", "Perusing", "Philosophising",
+    "Photosynthesizing", "Pollinating", "Pondering", "Pontificating", "Pouncing",
+    "Precipitating", "Prestidigitating", "Processing", "Proofing", "Propagating", "Puttering",
+    "Puzzling", "Quantumizing", "Razzle-dazzling", "Razzmatazzing", "Recombobulating",
+    "Reticulating", "Roosting", "Ruminating", "Sautéing", "Scampering", "Schlepping",
+    "Scurrying", "Seasoning", "Shenaniganing", "Shimmying", "Simmering", "Skedaddling",
+    "Sketching", "Slithering", "Smooshing", "Sock-hopping", "Spelunking", "Spinning",
+    "Sprouting", "Stewing", "Sublimating", "Swirling", "Swooping", "Symbioting",
+    "Synthesizing", "Tempering", "Thinking", "Thundering", "Tinkering", "Tomfoolering",
+    "Topsy-turvying", "Transfiguring", "Transmuting", "Twisting", "Undulating", "Unfurling",
+    "Unravelling", "Vibing", "Waddling", "Wandering", "Warping", "Whatchamacalliting",
+    "Whirlpooling", "Whirring", "Whisking", "Wibbling", "Working", "Wrangling", "Zesting",
+    "Zigzagging",
+];
+
+/// Past-tense verbs shown in the status row after a turn completes.
+pub const TURN_COMPLETION_VERBS: &[&str] = &[
+    "Baked", "Brewed", "Churned", "Cogitated", "Cooked", "Crunched",
+    "Pondered", "Processed", "Worked",
+];
+
+/// Select a random spinner verb.
+pub fn sample_spinner_verb(seed: usize) -> &'static str {
+    SPINNER_VERBS[seed % SPINNER_VERBS.len()]
+}
+
+/// Select a random completion verb.
+pub fn sample_completion_verb(seed: usize) -> &'static str {
+    TURN_COMPLETION_VERBS[seed % TURN_COMPLETION_VERBS.len()]
+}

src-rust/crates/query/src/lib.rs

@@ -689,6 +689,8 @@ const MAX_TOKENS_RECOVERY_MSG: &str =
      you were doing. Pick up mid-thought if that is where the cut happened. \
      Break remaining work into smaller pieces.";
 
+// Spinner verbs are imported from claurst_core::spinner
+
 /// Run the agentic query loop.
 ///
 /// This sends the conversation to the API, handles tool calls in a loop, and
@@ -1055,9 +1057,12 @@ pub async fn run_query_loop(
                 if let Some(provider) = provider {
                     debug!(provider = %provider_id_str, model = %model_id_str, "Dispatching to non-Anthropic provider");
 
-                    // Notify TUI that we're calling the provider
+                    // Notify TUI that we're calling the provider using a random spinner verb
                     if let Some(ref tx) = event_tx {
-                        let _ = tx.send(QueryEvent::Status(format!("Calling {} ({})…", provider.name(), model_id_str)));
+                        use claurst_core::sample_spinner_verb;
+                        let seed = (provider_id_str.len() ^ model_id_str.len()) as usize;
+                        let verb = sample_spinner_verb(seed);
+                        let _ = tx.send(QueryEvent::Status(format!("✳ {}…", verb)));
                     }
 
                     // Build ProviderRequest from the already-assembled request data.

src-rust/crates/tui/src/agents_view.rs

@@ -227,7 +227,7 @@ pub enum AgentsRoute {
 /// Full state for the agents menu overlay.
 #[derive(Debug, Clone)]
 pub struct AgentsMenuState {
-    pub open: bool,
+    pub visible: bool,
     pub route: AgentsRoute,
     pub definitions: Vec<AgentDefinition>,
     pub active_agents: Vec<AgentInfo>,
@@ -240,7 +240,7 @@ pub struct AgentsMenuState {
 impl AgentsMenuState {
     pub fn new() -> Self {
         Self {
-            open: false,
+            visible: false,
             route: AgentsRoute::List,
             definitions: Vec::new(),
             active_agents: Vec::new(),
@@ -257,11 +257,11 @@ impl AgentsMenuState {
         self.list_scroll = 0;
         self.route = AgentsRoute::List;
         self.project_root = Some(project_root.to_path_buf());
-        self.open = true;
+        self.visible = true;
     }
 
     pub fn close(&mut self) {
-        self.open = false;
+        self.visible = false;
     }
 
     pub fn select_prev(&mut self) {
@@ -560,7 +560,7 @@ fn write_editor_to_disk(path: &Path, editor: &AgentEditorState) -> Result<(), St
 
 /// Render the agents menu overlay.
 pub fn render_agents_menu(state: &AgentsMenuState, area: Rect, buf: &mut Buffer) {
-    if !state.open {
+    if !state.visible {
         return;
     }