@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-core/src/slash/mod.rs

@@ -227,7 +227,12 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
             agent_mode: true,
             plan_mode: false,
         },
-        "/release-notes" => message(crate::release_notes::text()),
+        "/release-notes"
+        | "/release_notes"
+        | "/release-note"
+        | "/release_note"
+        | "/releasenotes"
+        | "/releasenote" => message(crate::release_notes::text()),
         "/clear" => SlashResponse::Applied {
             markdown: "🧹 Conversation history cleared.".into(),
             effects: vec![SlashEffect::HistoryCleared],
@@ -315,6 +320,8 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
         "/models" => cmd_models(rest, config),
         "/thinking" | "/think" => cmd_thinking(rest, config),
         "/temperature" | "/temp" => cmd_temperature(rest, config),
+        "/steps" | "/max-steps" => cmd_steps(rest, config),
+        "/browser" => cmd_browser(rest, config),
         // `/searchProvider` is a documented camelCase alias (see UNDOCUMENTED_ALIASES).
         "/search-provider" | "/searchprovider" => cmd_extra_provider(
             "/search-provider",
@@ -513,14 +520,64 @@ fn cmd_plan(req: &SlashRequest, rest: &str) -> SlashResponse {
             markdown: "📋 Plan Mode **OFF**.".into(),
             effects: vec![SlashEffect::PlanModeChanged { enabled: false }],
         }
-    } else if trimmed == "list" {
+    } else if trimmed == "list" || trimmed.starts_with("list ") {
+        let list_arg = trimmed.trim_start_matches("list").trim();
         let ws = req.workspace();
         let plan_dir = ws.join(".agents").join("plans");
-        let mut entries = Vec::new();
-        if let Ok(rd) = std::fs::read_dir(&plan_dir) {
-            for entry in rd.flatten() {
-                let path = entry.path();
-                if path.is_file() {
+        if !list_arg.is_empty() {
+            let arg = list_arg;
+            let mut found_content = None;
+            if let Ok(rd) = std::fs::read_dir(&plan_dir) {
+                let mut files: Vec<_> = rd
+                    .flatten()
+                    .map(|e| e.path())
+                    .filter(|p| p.is_file())
+                    .collect();
+                files.sort_by(|a, b| b.file_name().cmp(&a.file_name()));
+                if let Ok(idx) = arg.parse::<usize>() {
+                    if let Some(path) = idx.checked_sub(1).and_then(|i| files.get(i)) {
+                        if let Ok(content) = std::fs::read_to_string(path) {
+                            let name = path
+                                .file_name()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or_default()
+                                .to_string();
+                            found_content = Some((name, content));
+                        }
+                    }
+                } else {
+                    for path in &files {
+                        let name = path
+                            .file_name()
+                            .and_then(|n| n.to_str())
+                            .unwrap_or_default()
+                            .to_string();
+                        if name.contains(arg) {
+                            if let Ok(content) = std::fs::read_to_string(path) {
+                                found_content = Some((name, content));
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            match found_content {
+                Some((name, content)) => message(format!("### Plan: {}\n\n{}", name, content)),
+                None => error(format!(
+                    "No saved plan matching \"{}\" under `.agents/plans/`",
+                    arg
+                )),
+            }
+        } else {
+            let mut entries = Vec::new();
+            if let Ok(rd) = std::fs::read_dir(&plan_dir) {
+                let mut files: Vec<_> = rd
+                    .flatten()
+                    .map(|e| e.path())
+                    .filter(|p| p.is_file())
+                    .collect();
+                files.sort_by(|a, b| b.file_name().cmp(&a.file_name()));
+                for (idx, path) in files.iter().enumerate() {
                     let name = path
                         .file_name()
                         .and_then(|n| n.to_str())
@@ -528,16 +585,23 @@ fn cmd_plan(req: &SlashRequest, rest: &str) -> SlashResponse {
                         .to_string();
                     let first_line = std::fs::read_to_string(&path)
                         .ok()
-                        .and_then(|s| s.lines().next().map(|l| l.trim().to_string()))
+                        .and_then(|s| {
+                            s.lines()
+                                .find(|l| !l.trim().is_empty())
+                                .map(|l| l.trim().trim_start_matches('#').trim().to_string())
+                        })
                         .unwrap_or_default();
-                    entries.push(format!("- **{}**: {}", name, first_line));
+                    entries.push(format!("- **[{}] `{}`**: {}", idx + 1, name, first_line));
                 }
             }
-        }
-        if entries.is_empty() {
-            message("No saved plans found under `.agents/plans/`.")
-        } else {
-            message(format!("### Saved Plans\n\n{}", entries.join("\n")))
+            if entries.is_empty() {
+                message("No saved plans found under `.agents/plans/`.")
+            } else {
+                message(format!(
+                    "### Saved Plans\n\n{}\n\n*Type `/plan list <number>` or `/plan show <name>` to view.*",
+                    entries.join("\n")
+                ))
+            }
         }
     } else if let Some(show_arg) = trimmed.strip_prefix("show") {
         let arg = show_arg.trim();
@@ -545,17 +609,35 @@ fn cmd_plan(req: &SlashRequest, rest: &str) -> SlashResponse {
         let plan_dir = ws.join(".agents").join("plans");
         let mut found_content = None;
         if let Ok(rd) = std::fs::read_dir(&plan_dir) {
-            for entry in rd.flatten() {
-                let path = entry.path();
-                let name = path
-                    .file_name()
-                    .and_then(|n| n.to_str())
-                    .unwrap_or_default()
-                    .to_string();
-                if name.contains(arg) {
-                    if let Ok(content) = std::fs::read_to_string(&path) {
+            let mut files: Vec<_> = rd
+                .flatten()
+                .map(|e| e.path())
+                .filter(|p| p.is_file())
+                .collect();
+            files.sort_by(|a, b| b.file_name().cmp(&a.file_name()));
+            if let Ok(idx) = arg.parse::<usize>() {
+                if let Some(path) = idx.checked_sub(1).and_then(|i| files.get(i)) {
+                    if let Ok(content) = std::fs::read_to_string(path) {
+                        let name = path
+                            .file_name()
+                            .and_then(|n| n.to_str())
+                            .unwrap_or_default()
+                            .to_string();
                         found_content = Some((name, content));
-                        break;
+                    }
+                }
+            } else {
+                for path in &files {
+                    let name = path
+                        .file_name()
+                        .and_then(|n| n.to_str())
+                        .unwrap_or_default()
+                        .to_string();
+                    if name.contains(arg) {
+                        if let Ok(content) = std::fs::read_to_string(path) {
+                            found_content = Some((name, content));
+                            break;
+                        }
                     }
                 }
             }
@@ -585,7 +667,15 @@ fn cmd_bool_toggle(
     config: &mut MintConfig,
 ) -> SlashResponse {
     match parse_on_off(rest) {
-        None if rest.is_empty() => needs_on_off(command, label),
+        None if rest.is_empty() => {
+            let mut response = needs_on_off(command, label);
+            if command == "/autoskill"
+                && let SlashResponse::NeedsChoice { options, .. } = &mut response
+            {
+                options[usize::from(!current)].label.push_str(" (current)");
+            }
+            response
+        }
         None => error(format!("Usage: {command} [on|off]")),
         Some(v) => {
             set(config, v);
@@ -917,16 +1007,33 @@ fn capitalize_effort(s: &str) -> String {
 fn cmd_thinking(rest: &str, config: &mut MintConfig) -> SlashResponse {
     let model = config.active_model().to_string();
     let supported = config.is_thinking_supported();
+    let has_native = MintConfig::has_native_thinking_api(&config.ai_provider, &model);
+    let mode_desc = if !supported {
+        "Non-text model (image/audio/embedding)"
+    } else if has_native {
+        "Native Reasoning API"
+    } else {
+        "Prompted CoT (<think>)"
+    };
     let (current_enabled, current_effort) = config.resolved_thinking();
     let raw = rest.trim().to_ascii_lowercase();
 
+    if !supported && raw != "off" && raw != "disable" && raw != "false" {
+        return message(format!(
+            "⚠️ **Thinking is not available for `{model}`**\n\n\
+             `{model}` is classified as a non-text model (image/audio/embedding), which does not support Chain-of-Thought reasoning."
+        ));
+    }
+
     if raw.is_empty() {
-        let status_label = if !supported {
-            "Not supported by active model".to_string()
-        } else if current_enabled {
-            format!("ON (Effort: {})", capitalize_effort(current_effort))
+        let status_label = if current_enabled {
+            format!(
+                "ON ({}, Effort: {})",
+                mode_desc,
+                capitalize_effort(current_effort)
+            )
         } else {
-            "OFF".to_string()
+            format!("OFF ({mode_desc})")
         };
 
         let mut choices = Vec::new();
@@ -966,14 +1073,15 @@ fn cmd_thinking(rest: &str, config: &mut MintConfig) -> SlashResponse {
             "⚠️ Thinking is **not supported** by the current active model.".to_string()
         } else if current_enabled {
             format!(
-                "✅ Thinking is **ON** (Effort: **{}**)",
-                capitalize_effort(current_effort)
+                "✅ Thinking is **ON** (Effort: **{}**, Mode: `{}`)",
+                capitalize_effort(current_effort),
+                mode_desc
             )
         } else {
-            "⏸️ Thinking is **OFF**".to_string()
+            format!("⏸️ Thinking is **OFF** (Mode: `{mode_desc}`)")
         };
         return message(format!(
-            "🧠 **Thinking Status**\n\n- Active Model: `{model}`\n- Supported: **{supported}**\n- State: {status_label}\n\nUsage: `/thinking [on|off|low|medium|high|extra_high]`"
+            "🧠 **Thinking Status**\n\n- Active Model: `{model}`\n- Supported: **{supported}** (`{mode_desc}`)\n- State: {status_label}\n\nUsage: `/thinking [on|off|low|medium|high|extra_high]`"
         ));
     }
 
@@ -1009,16 +1117,11 @@ fn cmd_thinking(rest: &str, config: &mut MintConfig) -> SlashResponse {
     config.thinking_enabled = new_enabled;
     config.thinking_effort = new_effort.clone();
 
-    let text = if !supported {
+    let text = if new_enabled {
         format!(
-            "🧠 Updated thinking preference for `{model}` to **{}** (Effort: **{}**).\n*Note: `{model}` may not natively emit reasoning tokens.*",
-            if new_enabled { "ON" } else { "OFF" },
-            capitalize_effort(&new_effort)
-        )
-    } else if new_enabled {
-        format!(
-            "🧠 Thinking **ON** for `{model}` (Effort: **{}**).",
-            capitalize_effort(&new_effort)
+            "🧠 Thinking **ON** for `{model}` (Effort: **{}**, Mode: `{}`).",
+            capitalize_effort(&new_effort),
+            mode_desc
         )
     } else {
         format!("🧠 Thinking **OFF** for `{model}`.")
@@ -1236,6 +1339,162 @@ fn cmd_temperature(rest: &str, config: &mut MintConfig) -> SlashResponse {
     }
 }
 
+fn cmd_steps(rest: &str, config: &mut MintConfig) -> SlashResponse {
+    let raw = rest.trim();
+    let current_steps = config.resolved_agent_max_steps();
+    if raw.is_empty() {
+        return SlashResponse::NeedsChoice {
+            command: "/steps".into(),
+            title: format!(
+                "⏱️ Agent Step Limit: {} steps per turn\nSelect a preset or run `/steps <10-200>`",
+                current_steps
+            ),
+            options: vec![
+                SlashChoice {
+                    label: format!(
+                        "25 steps — Fast & frugal{}",
+                        if current_steps == 25 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "25".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "40 steps — Default standard{}",
+                        if current_steps == 40 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "40".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "60 steps — Extended workflows{}",
+                        if current_steps == 60 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "60".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "80 steps — Heavy deep coding{}",
+                        if current_steps == 80 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "80".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "100 steps — Long-running autonomous{}",
+                        if current_steps == 100 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "100".into(),
+                },
+                SlashChoice {
+                    label: "Reset to default (40 steps)".into(),
+                    value: "reset".into(),
+                },
+            ],
+        };
+    }
+
+    if raw.eq_ignore_ascii_case("status") {
+        return message(format!(
+            "⏱️ **Agent Step Budget Status**\n\n\
+             - **Current Limit**: `{}` steps per turn\n\
+             - **Step Warning**: Injected into prompt & observations at step `{}`\n\
+             - **Wrap-up Synthesis**: Enforced on final step `{}` (synthesizes findings without tools)\n\
+             - **Allowed Range**: 10 – 200 steps\n\
+             - **Default**: {} steps\n\n\
+             To adjust: `/steps <number>` or `/steps reset`",
+            current_steps,
+            current_steps.saturating_sub(5),
+            current_steps,
+            crate::system::config::DEFAULT_AGENT_MAX_STEPS
+        ));
+    }
+
+    if raw.eq_ignore_ascii_case("reset") || raw.eq_ignore_ascii_case("default") {
+        config.agent_max_steps = crate::system::config::DEFAULT_AGENT_MAX_STEPS;
+        return SlashResponse::Applied {
+            markdown: format!(
+                "🔄 Agent step limit reset to default (**{}** steps per turn).",
+                crate::system::config::DEFAULT_AGENT_MAX_STEPS
+            ),
+            effects: vec![SlashEffect::ConfigChanged],
+        };
+    }
+
+    match raw.parse::<usize>() {
+        Ok(val) => {
+            if !(10..=200).contains(&val) {
+                return error(format!(
+                    "Step limit must be between 10 and 200 steps (received `{val}`)."
+                ));
+            }
+            config.agent_max_steps = val;
+            SlashResponse::Applied {
+                markdown: format!(
+                    "⏱️ Agent step limit set to **{}** steps per turn (Warning at step {}, Wrap-up at step {}).",
+                    val,
+                    val.saturating_sub(5),
+                    val
+                ),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        Err(_) => error(format!(
+            "Invalid step limit `{raw}`. Please specify a number between 10 and 200, or `reset`."
+        )),
+    }
+}
+
+fn cmd_browser(rest: &str, config: &mut MintConfig) -> SlashResponse {
+    let raw = rest.trim().to_ascii_lowercase();
+    let custom_exe = config
+        .extra
+        .get("browserExecutable")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("");
+    let exe_display = if !custom_exe.trim().is_empty() {
+        custom_exe.trim()
+    } else {
+        "Auto-detect (Chrome / Chromium / Edge)"
+    };
+
+    if !raw.is_empty() && raw != "status" {
+        return SlashResponse::Message {
+            markdown: "Usage: `/browser` or `/browser status`.\n\n*Note: Agent tools `browser_*` have been superseded by headless Chrome shell execution and `mint browser run`.*".into(),
+        };
+    }
+
+    SlashResponse::Message {
+        markdown: format!(
+            "### 🌐 Browser Automation Status\n\n\
+             - **Engine**: Headless Chromium (CLI shell execution)\n\
+             - **Executable**: `{}`\n\
+             - **Interactive Runner**: `mint browser run --file <workflow.json>`\n\n\
+             Browsing is executed via `google-chrome --headless=new` through `run_shell` or bounded headless workflows with `mint browser run`.",
+            exe_display
+        ),
+    }
+}
+
 async fn cmd_temperature_async(rest: &str, config: &mut MintConfig) -> SlashResponse {
     let tokens: Vec<&str> = rest.split_whitespace().collect();
     if tokens.len() == 1 {
@@ -2540,17 +2799,24 @@ mod tests {
     #[test]
     fn release_notes_are_available_on_every_surface() {
         for surface in ["cli", "desktop", "web"] {
-            match execute(
-                &req_surface("/release-notes", surface),
-                &mut MintConfig::default(),
-            ) {
-                SlashResponse::Message { markdown } => {
-                    assert!(markdown.starts_with("# Release Notes - Mint Agent"));
+            for cmd in [
+                "/release-notes",
+                "/release_notes",
+                "/release-note",
+                "/release_note",
+            ] {
+                match execute(&req_surface(cmd, surface), &mut MintConfig::default()) {
+                    SlashResponse::Message { markdown } => {
+                        assert!(
+                            markdown.starts_with("# Release Notes - Mint Agent"),
+                            "failed for command {cmd} on {surface}"
+                        );
+                    }
+                    other => panic!(
+                        "expected release notes for {cmd} on {surface}, got {}",
+                        serde_json::to_value(other).unwrap()
+                    ),
                 }
-                other => panic!(
-                    "expected release notes on {surface}, got {}",
-                    serde_json::to_value(other).unwrap()
-                ),
             }
         }
     }
@@ -2936,6 +3202,46 @@ mod tests {
                 serde_json::to_value(other)
             ),
         }
+
+        let temp = std::env::temp_dir().join(format!("mint-core-plan-test-{}", std::process::id()));
+        let plans_dir = temp.join(".agents").join("plans");
+        std::fs::create_dir_all(&plans_dir).unwrap();
+        std::fs::write(
+            plans_dir.join("20261102-190000-arch.md"),
+            "# Architecture Plan\n1. Module seam",
+        )
+        .unwrap();
+
+        let req_ws = |input: &str| SlashRequest {
+            input: input.to_string(),
+            surface: Some("cli".to_string()),
+            cwd: Some(temp.to_string_lossy().to_string()),
+            chat_id: None,
+        };
+
+        match execute(&req_ws("/plan list"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Architecture Plan"));
+                assert!(markdown.contains("20261102-190000-arch.md"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        match execute(&req_ws("/plan list 1"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("# Architecture Plan"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        match execute(&req_ws("/plan show 1"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("# Architecture Plan"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        let _ = std::fs::remove_dir_all(temp);
     }
 
     #[test]
@@ -3116,15 +3422,25 @@ mod tests {
             other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
         }
 
-        // 5. Non-reasoning model accepts preference with advisory note
+        // 5. Non-native chat model accepts preference with Prompted CoT mode
         cfg.ai_provider = "openai".into();
         cfg.openai_model = "gpt-4o".into();
         match execute(&req("/thinking on"), &mut cfg) {
             SlashResponse::Applied { markdown, .. } => {
-                assert!(markdown.contains("may not natively emit reasoning tokens"));
+                assert!(markdown.contains("Prompted CoT (<think>)"));
             }
             other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
         }
+
+        // 6. Non-text media model rejects enabling thinking
+        cfg.ai_provider = "gemini".into();
+        cfg.gemini_model = "nano-banana-pro-preview".into();
+        match execute(&req("/thinking on"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Thinking is not available"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
     }
 
     #[tokio::test]
@@ -3173,4 +3489,114 @@ mod tests {
             ),
         }
     }
+
+    #[test]
+    fn steps_slash_command_behavior() {
+        let mut cfg = MintConfig::default();
+        assert_eq!(cfg.resolved_agent_max_steps(), 40);
+
+        // 1. Bare /steps returns NeedsChoice with presets
+        match execute(&req("/steps"), &mut cfg) {
+            SlashResponse::NeedsChoice {
+                command, options, ..
+            } => {
+                assert_eq!(command, "/steps");
+                assert!(options.iter().any(|o| o.value == "25"));
+                assert!(
+                    options
+                        .iter()
+                        .any(|o| o.value == "40" && o.label.contains("(current)"))
+                );
+                assert!(options.iter().any(|o| o.value == "60"));
+                assert!(options.iter().any(|o| o.value == "reset"));
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. /steps status returns informative message
+        match execute(&req("/steps status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Agent Step Budget Status"));
+                assert!(markdown.contains("40"));
+                assert!(markdown.contains("35"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. /steps 60 sets agent_max_steps to 60 with ConfigChanged effect
+        match execute(&req("/steps 60"), &mut cfg) {
+            SlashResponse::Applied { markdown, effects } => {
+                assert!(markdown.contains("60"));
+                assert_eq!(cfg.agent_max_steps, 60);
+                assert_eq!(cfg.resolved_agent_max_steps(), 60);
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 4. Out-of-bounds rejected
+        match execute(&req("/steps 5"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("between 10 and 200"));
+            }
+            other => panic!(
+                "expected Error Message, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        match execute(&req("/steps 250"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("between 10 and 200"));
+            }
+            other => panic!(
+                "expected Error Message, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 5. /steps reset reverts back to default 40
+        match execute(&req("/steps reset"), &mut cfg) {
+            SlashResponse::Applied { markdown, effects } => {
+                assert!(markdown.contains("40"));
+                assert_eq!(cfg.agent_max_steps, 40);
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+    }
+
+    #[test]
+    fn browser_slash_command_behavior() {
+        let mut cfg = MintConfig::default();
+
+        // 1. Bare /browser returns status message
+        match execute(&req("/browser"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Browser Automation Status"));
+                assert!(markdown.contains("Headless Chromium"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 2. /browser status also returns informative message
+        match execute(&req("/browser status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Browser Automation Status"));
+                assert!(markdown.contains("mint browser run"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. /browser with invalid subcommand gives usage
+        match execute(&req("/browser on"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Usage: `/browser` or `/browser status`"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+    }
 }

package/crates/mint-core/src/slash/models.rs

@@ -69,7 +69,12 @@ pub fn popular_models_for_provider(provider: &str) -> &'static [&'static str] {
     }
 }
 
-pub const DEEPSEEK_MODEL_PRESETS: &[&str] = &["deepseek-chat", "deepseek-reasoner"];
+pub const DEEPSEEK_MODEL_PRESETS: &[&str] = &[
+    "deepseek-flash",
+    "deepseek-v4-pro",
+    "deepseek-chat",
+    "deepseek-reasoner",
+];
 
 pub const HUGGINGFACE_MODEL_PRESETS: &[&str] = &[
     "Qwen/Qwen3.6-27B",