@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-core/src/system/config.rs

@@ -137,6 +137,13 @@ pub struct MintConfig {
     pub disabled_tools: Vec<String>,
     pub agents: Vec<AgentConfig>,
     pub enable_agent_collaboration: bool,
+    /// Maximum number of sub-agents run concurrently within a swarm batch
+    /// (1..=8, default 4). Clamped when used.
+    #[serde(default = "default_swarm_max_parallel")]
+    pub swarm_max_parallel: usize,
+    /// Maximum steps allowed per agent turn (default 40, clamped to 10..=200).
+    #[serde(default = "default_agent_max_steps")]
+    pub agent_max_steps: usize,
     /// When true, reflection after a reusable task proposes a new or refined
     /// workspace skill. Every proposal needs interactive approval before saving.
     /// Off by default; `/autoskill on` enables proposals, not unattended writes.
@@ -191,6 +198,16 @@ fn default_thinking_effort() -> String {
     "medium".into()
 }
 
+fn default_swarm_max_parallel() -> usize {
+    crate::swarm::DEFAULT_MAX_PARALLEL
+}
+
+pub const DEFAULT_AGENT_MAX_STEPS: usize = 40;
+
+fn default_agent_max_steps() -> usize {
+    DEFAULT_AGENT_MAX_STEPS
+}
+
 /// Thinking/reasoning configuration for a specific model.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
@@ -285,6 +302,15 @@ impl MintConfig {
     ) -> Option<PermissionDecision> {
         permission_decision_for(&self.permission_rules, tool, subject, project_root)
     }
+
+    /// Resolved maximum steps per turn, clamped between 10 and 200 (defaults to 40).
+    pub fn resolved_agent_max_steps(&self) -> usize {
+        if self.agent_max_steps == 0 {
+            DEFAULT_AGENT_MAX_STEPS
+        } else {
+            self.agent_max_steps.clamp(10, 200)
+        }
+    }
 }
 
 /// Core matching logic behind [`MintConfig::permission_decision`], exposed as a
@@ -364,9 +390,12 @@ impl Default for MintConfig {
     fn default() -> Self {
         let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
         let current_directory = std::env::current_dir().unwrap_or_else(|_| home.clone());
-        let allowed_paths = vec![
+        let temp_dir = std::env::temp_dir();
+        let canonical_temp = temp_dir.canonicalize().ok();
+        let mut allowed_paths = vec![
             home.clone(),
             current_directory,
+            temp_dir.clone(),
             home.join("Desktop"),
             home.join("Documents"),
             home.join("Downloads"),
@@ -374,6 +403,25 @@ impl Default for MintConfig {
             home.join("Music"),
             home.join("Videos"),
         ];
+        if let Some(canonical) = canonical_temp {
+            if canonical != temp_dir && !allowed_paths.contains(&canonical) {
+                allowed_paths.push(canonical);
+            }
+        }
+        #[cfg(unix)]
+        {
+            let slash_tmp = PathBuf::from("/tmp");
+            if slash_tmp.exists() {
+                if !allowed_paths.contains(&slash_tmp) {
+                    allowed_paths.push(slash_tmp.clone());
+                }
+                if let Ok(canonical_slash_tmp) = slash_tmp.canonicalize() {
+                    if !allowed_paths.contains(&canonical_slash_tmp) {
+                        allowed_paths.push(canonical_slash_tmp);
+                    }
+                }
+            }
+        }
         Self {
             theme: "dark".into(),
             tui_theme: "dark".into(),
@@ -399,7 +447,7 @@ impl Default for MintConfig {
             local_openai_num_ctx: 32_768,
             ollama_host: String::new(),
             ollama_model: "llama3:latest".into(),
-            ollama_num_ctx: 8192,
+            ollama_num_ctx: 32_768,
             nanobanana_model: "gemini-3.1-flash-image".into(),
             image_gen_provider: "nanobanana".into(),
             dalle_model: "gpt-image-1".into(),
@@ -434,6 +482,8 @@ impl Default for MintConfig {
             disabled_tools: Vec::new(),
             agents: default_agents(),
             enable_agent_collaboration: false,
+            swarm_max_parallel: crate::swarm::DEFAULT_MAX_PARALLEL,
+            agent_max_steps: DEFAULT_AGENT_MAX_STEPS,
             auto_skill_writing: false,
             memory_recall: true,
             auto_fact_extraction: true,
@@ -723,53 +773,131 @@ impl MintConfig {
         }
     }
 
-    /// Returns whether thinking/reasoning is supported by a given provider & model.
-    pub fn is_thinking_supported_for_model(provider: &str, model: &str) -> bool {
-        let p = provider.to_ascii_lowercase();
-        let m = model.to_ascii_lowercase();
+    /// Returns true if the model ID refers to a non-text media or embedding model
+    /// (e.g. image generation/editing, TTS, STT, embeddings, moderation, or live-only audio).
+    pub fn is_non_text_model(model: &str) -> bool {
+        let m = model.trim().to_ascii_lowercase();
+        if m.is_empty() {
+            return true;
+        }
+        m.contains("banana")
+            || m.contains("imagen")
+            || m.contains("image")
+            || m.contains("dall-e")
+            || m.contains("flux")
+            || m.contains("sdxl")
+            || m.contains("sd3")
+            || m.contains("ideogram")
+            || m.contains("veo-")
+            || m.contains("whisper")
+            || m.contains("tts")
+            || m.contains("embed")
+            || m.contains("aqa")
+            || m.contains("moderation")
+            || m.contains("native-audio")
+            || m.contains("-live-")
+            || m.ends_with("-live")
+    }
+
+    /// Returns whether the provider's HTTP endpoint natively accepts a dedicated thinking/reasoning
+    /// payload parameter for this model (as opposed to using the prompt-based `<think>` CoT fallback).
+    pub fn has_native_thinking_api(provider: &str, model: &str) -> bool {
+        if Self::is_non_text_model(model) {
+            return false;
+        }
+        let p = provider.trim().to_ascii_lowercase();
+        let m = model.trim().to_ascii_lowercase();
         if p == "gemini" {
             return m.contains("2.5")
-                || m.contains("2.0")
+                || m.contains("2.0-flash-thinking")
                 || m.contains("3.")
+                || m.contains("gemini-3-")
+                || m.ends_with("gemini-3")
+                || m.contains("4.")
+                || m.contains("gemini-4-")
+                || m.contains("argon")
                 || m.contains("thinking");
         }
         if p == "anthropic" {
             return m.contains("3-7")
                 || m.contains("3.7")
-                || m.contains("sonnet-5")
-                || m.contains("opus-5")
                 || m.contains("sonnet-4")
-                || m.contains("opus-4");
+                || m.contains("opus-4")
+                || m.contains("haiku-4")
+                || m.contains("claude-4")
+                || m.contains("sonnet-5")
+                || m.contains("opus-5");
         }
         if p == "openai" || p == "local_openai" {
-            return m.starts_with("o1")
-                || m.starts_with("o3")
+            let slug = m.rsplit('/').next().unwrap_or(&m);
+            return slug.starts_with("o1")
+                || slug.starts_with("o3")
+                || slug.starts_with("o4")
                 || m.contains("thinking")
                 || m.contains("reason")
-                || m.contains("gpt-5");
+                || m.contains("gpt-5")
+                || m.contains("r1")
+                || m.contains("qwq");
         }
         if p == "deepseek" {
-            return m.contains("reasoner") || m.contains("r1") || m.contains("deepseek");
+            return m.contains("flash")
+                || m.contains("v4")
+                || m.contains("reasoner")
+                || m.contains("r1")
+                || m.contains("thinking");
         }
         if p == "openrouter" {
             return m.contains("o1")
                 || m.contains("o3")
+                || m.contains("o4")
+                || m.contains("gpt-5")
                 || m.contains("thinking")
                 || m.contains("reason")
                 || m.contains("r1")
                 || m.contains("qwq")
-                || m.contains("glm")
-                || m.contains("deepseek");
+                || m.contains("deepseek-flash")
+                || m.contains("deepseek-v4")
+                || m.contains("gemini-2.5")
+                || m.contains("gemini-3")
+                || m.contains("claude-3-7")
+                || m.contains("claude-3.7")
+                || m.contains("claude-4")
+                || m.contains("sonnet-4")
+                || m.contains("opus-4")
+                || m.contains("sonnet-5")
+                || m.contains("opus-5");
         }
         if p == "ollama" {
             return m.contains("r1")
                 || m.contains("qwq")
+                || m.contains("qwen3")
                 || m.contains("thinking")
                 || m.contains("deepseek");
         }
         false
     }
 
+    /// Returns whether thinking/reasoning is supported by a given provider & model
+    /// (either via native provider API parameters or prompt-based `<think>` CoT fallback).
+    /// Only non-text models (image generation, TTS/STT, embeddings) return `false`.
+    pub fn is_thinking_supported_for_model(provider: &str, model: &str) -> bool {
+        if Self::is_non_text_model(model) {
+            return false;
+        }
+        let p = provider.trim().to_ascii_lowercase();
+        matches!(
+            p.as_str(),
+            "gemini"
+                | "anthropic"
+                | "openai"
+                | "local_openai"
+                | "deepseek"
+                | "openrouter"
+                | "ollama"
+                | "huggingface"
+        ) || p.starts_with("custom:")
+    }
+
     /// Returns whether the active model supports thinking/reasoning.
     pub fn is_thinking_supported(&self) -> bool {
         Self::is_thinking_supported_for_model(&self.ai_provider, self.active_model())
@@ -778,6 +906,9 @@ impl MintConfig {
     /// Resolves thinking enabled state for a model.
     pub fn resolved_thinking_enabled_for_model(&self, provider: &str, model: &str) -> bool {
         let model_clean = model.trim();
+        if !Self::is_thinking_supported_for_model(provider, model_clean) {
+            return false;
+        }
         if let Some(cfg) = self.model_thinking_configs.get(model_clean) {
             return cfg.enabled;
         }
@@ -787,8 +918,8 @@ impl MintConfig {
                 return v.enabled;
             }
         }
-        // If not explicitly configured, enable by default only if model supports it
-        if Self::is_thinking_supported_for_model(provider, model) {
+        // If not explicitly overridden per-model, enable by default for models with native thinking API
+        if Self::has_native_thinking_api(provider, model_clean) {
             self.thinking_enabled
         } else {
             false
@@ -1012,18 +1143,28 @@ fn is_test_environment() -> bool {
     false
 }
 
-pub fn config_path() -> Result<PathBuf, ConfigError> {
+/// Returns the root configuration directory for Mint (`~/.config/mint`).
+pub fn mint_config_dir() -> Option<PathBuf> {
+    if let Ok(override_dir) = std::env::var("MINT_CONFIG_DIR") {
+        return Some(PathBuf::from(override_dir));
+    }
     if let Ok(override_path) = std::env::var("MINT_CONFIG_PATH") {
-        return Ok(PathBuf::from(override_path));
+        if let Some(parent) = Path::new(&override_path).parent() {
+            return Some(parent.to_path_buf());
+        }
     }
     if is_test_environment() {
-        let tmp = std::env::temp_dir()
-            .join("mint-test")
-            .join("mint-config.json");
-        return Ok(tmp);
+        return Some(std::env::temp_dir().join("mint-test"));
+    }
+    dirs::config_dir().map(|dir| dir.join("mint"))
+}
+
+pub fn config_path() -> Result<PathBuf, ConfigError> {
+    if let Ok(override_path) = std::env::var("MINT_CONFIG_PATH") {
+        return Ok(PathBuf::from(override_path));
     }
-    dirs::config_dir()
-        .map(|directory| directory.join("mint").join("mint-config.json"))
+    mint_config_dir()
+        .map(|directory| directory.join("mint-config.json"))
         .ok_or(ConfigError::ConfigDirectoryUnavailable)
 }
 
@@ -1171,9 +1312,9 @@ fn default_sandbox_command() -> &'static str {
 
 fn runtime_extra_defaults() -> BTreeMap<String, Value> {
     serde_json::from_value(serde_json::json!({
-        "automationBrowser": "chromium",
-        "browserDebugUrl": "http://127.0.0.1:9222/json/list",
-        "browserExtensionContextUrl": "http://127.0.0.1:3212/context",
+        "browserExecutable": "",
+        "browserViewportWidth": 1440,
+        "browserViewportHeight": 900,
         "proactiveInterval": 60,
         "proactiveCooldown": 120,
         "enableHeadlessTaskQueue": false,
@@ -1357,7 +1498,7 @@ mod tests {
         // Default openai_model is a GPT-5 family model.
         assert_eq!(window_for("openai"), 400_000);
         assert_eq!(window_for("deepseek"), 128_000);
-        assert_eq!(window_for("ollama"), 8_192); // default ollama_num_ctx
+        assert_eq!(window_for("ollama"), 32_768); // default ollama_num_ctx
         assert_eq!(window_for("local_openai"), 32_768); // default local_openai_num_ctx
         assert_eq!(window_for("huggingface"), 128_000);
         assert_eq!(window_for("openrouter"), 128_000); // default openrouter_num_ctx
@@ -1760,7 +1901,7 @@ mod tests {
     fn test_thinking_configuration_and_resolution() {
         let mut config = MintConfig::default();
 
-        // Support checks
+        // All text/chat models support thinking (via native API or prompt fallback)
         assert!(MintConfig::is_thinking_supported_for_model(
             "anthropic",
             "claude-3-7-sonnet"
@@ -1769,6 +1910,10 @@ mod tests {
             "gemini",
             "gemini-2.5-pro"
         ));
+        assert!(MintConfig::is_thinking_supported_for_model(
+            "gemini",
+            "gemini-3-flash-preview"
+        ));
         assert!(MintConfig::is_thinking_supported_for_model(
             "openai", "o3-mini"
         ));
@@ -1776,15 +1921,60 @@ mod tests {
             "deepseek",
             "deepseek-reasoner"
         ));
-        assert!(!MintConfig::is_thinking_supported_for_model(
+        assert!(MintConfig::is_thinking_supported_for_model(
+            "deepseek",
+            "deepseek-flash"
+        ));
+        assert!(MintConfig::is_thinking_supported_for_model(
+            "deepseek",
+            "deepseek-v4-pro"
+        ));
+        assert!(MintConfig::is_thinking_supported_for_model(
             "openai", "gpt-4o"
         ));
-        assert!(!MintConfig::is_thinking_supported_for_model(
+        assert!(MintConfig::is_thinking_supported_for_model(
             "anthropic",
             "claude-3-5-haiku"
         ));
 
-        // Global default resolution
+        // Non-text models (image / audio / embedding) do NOT support thinking
+        assert!(!MintConfig::is_thinking_supported_for_model(
+            "gemini",
+            "nano-banana-pro-preview"
+        ));
+        assert!(!MintConfig::is_thinking_supported_for_model(
+            "gemini",
+            "gemini-nano-banana-2.1"
+        ));
+        assert!(!MintConfig::is_thinking_supported_for_model(
+            "gemini",
+            "imagen-3.0-generate-002"
+        ));
+        assert!(!MintConfig::is_thinking_supported_for_model(
+            "openai",
+            "text-embedding-3-small"
+        ));
+
+        // Native thinking API detection
+        assert!(MintConfig::has_native_thinking_api(
+            "deepseek",
+            "deepseek-flash"
+        ));
+        assert!(MintConfig::has_native_thinking_api(
+            "deepseek",
+            "deepseek-v4-pro"
+        ));
+        assert!(!MintConfig::has_native_thinking_api(
+            "deepseek",
+            "deepseek-chat"
+        ));
+        assert!(MintConfig::has_native_thinking_api(
+            "gemini",
+            "gemini-3-flash-preview"
+        ));
+        assert!(!MintConfig::has_native_thinking_api("openai", "gpt-4o"));
+
+        // Global default resolution for native thinking model
         config.ai_provider = "anthropic".into();
         config.anthropic_model = "claude-3-7-sonnet".into();
         let (enabled, effort) = config.resolved_thinking();
@@ -1802,10 +1992,51 @@ mod tests {
         let (enabled, _) = config.resolved_thinking();
         assert!(!enabled);
 
-        // Unsupported model always resolves enabled to false
+        // Standard chat model without native thinking API defaults to false until toggled on
         config.ai_provider = "openai".into();
         config.openai_model = "gpt-4o".into();
         let (enabled, _) = config.resolved_thinking();
         assert!(!enabled);
+        // Once user toggles it on, it enables thinking (via prompt fallback)
+        config.set_model_thinking("gpt-4o", true, "high");
+        let (enabled, effort) = config.resolved_thinking();
+        assert!(enabled);
+        assert_eq!(effort, "high");
+
+        // Non-text model always resolves enabled to false even if overridden
+        config.ai_provider = "gemini".into();
+        config.gemini_model = "nano-banana-pro-preview".into();
+        config.set_model_thinking("nano-banana-pro-preview", true, "high");
+        let (enabled, _) = config.resolved_thinking();
+        assert!(!enabled);
+    }
+
+    #[test]
+    fn test_agent_max_steps_config_and_clamping() {
+        let mut config = MintConfig::default();
+        assert_eq!(config.agent_max_steps, DEFAULT_AGENT_MAX_STEPS);
+        assert_eq!(config.resolved_agent_max_steps(), 40);
+
+        // Clamping to min 10
+        config.agent_max_steps = 3;
+        assert_eq!(config.resolved_agent_max_steps(), 10);
+
+        // Clamping to max 200
+        config.agent_max_steps = 500;
+        assert_eq!(config.resolved_agent_max_steps(), 200);
+
+        // Zero defaults to 40
+        config.agent_max_steps = 0;
+        assert_eq!(config.resolved_agent_max_steps(), 40);
+
+        // Custom in-range value
+        config.agent_max_steps = 75;
+        assert_eq!(config.resolved_agent_max_steps(), 75);
+
+        // Deserialization with camelCase agentMaxSteps
+        let json_str = r#"{"agentMaxSteps": 60}"#;
+        let deserialized: MintConfig = serde_json::from_str(json_str).unwrap();
+        assert_eq!(deserialized.agent_max_steps, 60);
+        assert_eq!(deserialized.resolved_agent_max_steps(), 60);
     }
 }

package/crates/mint-core/src/system/mint_web.rs

@@ -11,13 +11,19 @@ use std::{
 static SERVERS: LazyLock<Mutex<HashMap<Option<String>, String>>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 
+#[derive(Debug)]
+struct WebLaunch {
+    job_id: String,
+    reused: bool,
+}
+
 fn launch(
     cwd: &Path,
     owner: Option<String>,
     config: &MintConfig,
     program: Command,
     ports: &[u16],
-) -> Result<String, String> {
+) -> Result<WebLaunch, String> {
     crate::assert_path_capability(cwd, crate::Capability::Write, config)
         .map_err(|e| e.to_string())?;
     let mut servers = SERVERS.lock().map_err(|e| e.to_string())?;
@@ -25,7 +31,10 @@ fn launch(
         && let Ok(job) = crate::bg_shell::job_json(id, false)
     {
         if job["status"] == "running" {
-            return Ok(id.clone());
+            return Ok(WebLaunch {
+                job_id: id.clone(),
+                reused: true,
+            });
         }
         if job["status"] == "stopping" {
             return Err("Mint Web is stopping; try again after it stops.".into());
@@ -46,7 +55,10 @@ fn launch(
     })
     .map_err(|e| e.to_string())?;
     servers.insert(owner, job.id.clone());
-    Ok(job.id)
+    Ok(WebLaunch {
+        job_id: job.id,
+        reused: false,
+    })
 }
 
 fn executable() -> Result<PathBuf, String> {
@@ -83,10 +95,16 @@ pub fn command(
         return Err("Usage: /mint-web".into());
     }
     let mut program = Command::new(executable()?);
-    program.arg("web");
-    let id = launch(cwd, owner, config, program, &[9000, 3000])?;
+    program.args(["web", "--open"]);
+    let launch = launch(cwd, owner, config, program, &[9000, 3000])?;
+    let id = launch.job_id;
+    let browser_notice = if launch.reused {
+        "Mint Web is already running. Open the URL above to return to it."
+    } else {
+        "Your browser will open automatically when ready."
+    };
     Ok(format!(
-        "Mint Web background terminal: `{id}`\n\nOpen http://localhost:9000 once startup completes. It stops when this Mint backend closes.\n\nUse `/shells show {id}` for startup logs or `/shells stop {id}` to stop it."
+        "Mint Web background terminal: `{id}`\n\nMint Web: **http://localhost:9000**\n{browser_notice}\n\nIt stops when this Mint backend closes. Use `/shells show {id}` for startup logs or `/shells stop {id}` to stop it."
     ))
 }
 
@@ -139,14 +157,16 @@ mod tests {
             &[],
         )
         .unwrap();
-        assert_eq!(first, second);
+        assert!(!first.reused);
+        assert!(second.reused);
+        assert_eq!(first.job_id, second.job_id);
         assert!(crate::bg_shell::accessible(
-            &first,
+            &first.job_id,
             &Some("web-launch-test".into())
         ));
-        crate::bg_shell::kill_job(&first).unwrap();
+        crate::bg_shell::kill_job(&first.job_id).unwrap();
         let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
-        while crate::bg_shell::job_json(&first, false).unwrap()["status"] == "stopping" {
+        while crate::bg_shell::job_json(&first.job_id, false).unwrap()["status"] == "stopping" {
             assert!(std::time::Instant::now() < deadline);
             std::thread::sleep(std::time::Duration::from_millis(20));
         }
@@ -158,7 +178,8 @@ mod tests {
             &[],
         )
         .unwrap();
-        assert_ne!(first, next);
-        crate::bg_shell::kill_job(&next).unwrap();
+        assert!(!next.reused);
+        assert_ne!(first.job_id, next.job_id);
+        crate::bg_shell::kill_job(&next.job_id).unwrap();
     }
 }