@pheem49/mint 1.16.0 → 1.17.0

package/crates/mint-core/src/search/web_search.rs

@@ -167,9 +167,12 @@ async fn enrich_with_og_images(hits: Vec<SearchHit>, max_fetch: usize) -> Vec<Se
     hits.into_iter()
         .enumerate()
         .map(|(i, mut h)| {
-            if i < resolved.len() {
+            if i < resolved.len() && resolved[i].is_some() {
                 h.image_url = resolved[i].clone();
             }
+            if let Some(img) = h.image_url.take() {
+                h.image_url = Some(normalize_web_search_image_url(&img));
+            }
             h
         })
         .collect()
@@ -342,11 +345,11 @@ async fn brave_search(
             let image_url = item["thumbnail"]["original"]
                 .as_str()
                 .filter(|s| !s.is_empty())
-                .map(|s| s.replace("&amp;", "&"))
+                .map(normalize_web_search_image_url)
                 .or_else(|| {
                     item["thumbnail"]["src"]
                         .as_str()
-                        .and_then(unwrap_brave_proxy_url)
+                        .map(normalize_web_search_image_url)
                 });
             Some(SearchHit {
                 title: item["title"].as_str()?.to_owned(),
@@ -442,6 +445,24 @@ pub(crate) fn unwrap_brave_proxy_url(url: &str) -> Option<String> {
     }
 }
 
+/// Normalizes search result image URLs: unwraps Brave proxy URLs, unescapes XML entities,
+/// and repairs known CDN quirks (such as Twitter profile banners missing size dimensions).
+pub fn normalize_web_search_image_url(url: &str) -> String {
+    let unescaped = unwrap_brave_proxy_url(url).unwrap_or_else(|| url.to_owned());
+    let unescaped = unescaped.replace("&amp;", "&");
+    // Normalize Twitter/X profile banner URLs:
+    // https://pbs.twimg.com/profile_banners/<id>/<timestamp> -> append /1500x500 if missing size
+    if unescaped.contains("pbs.twimg.com/profile_banners/") {
+        let trimmed = unescaped.trim_end_matches('/');
+        if let Some((_, last)) = trimmed.rsplit_once('/') {
+            if !last.is_empty() && last.chars().all(|c| c.is_ascii_digit()) {
+                return format!("{trimmed}/1500x500");
+            }
+        }
+    }
+    unescaped
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -457,4 +478,24 @@ mod tests {
             )
         );
     }
+
+    #[test]
+    fn test_normalize_twitter_profile_banner() {
+        let raw = "https://pbs.twimg.com/profile_banners/1366430884698546176/1684330404";
+        assert_eq!(
+            normalize_web_search_image_url(raw),
+            "https://pbs.twimg.com/profile_banners/1366430884698546176/1684330404/1500x500"
+        );
+
+        let trailing_slash =
+            "https://pbs.twimg.com/profile_banners/1366430884698546176/1684330404/";
+        assert_eq!(
+            normalize_web_search_image_url(trailing_slash),
+            "https://pbs.twimg.com/profile_banners/1366430884698546176/1684330404/1500x500"
+        );
+
+        let already_sized =
+            "https://pbs.twimg.com/profile_banners/1366430884698546176/1684330404/1500x500";
+        assert_eq!(normalize_web_search_image_url(already_sized), already_sized);
+    }
 }

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

@@ -315,6 +315,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",
@@ -585,7 +587,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);
@@ -1236,6 +1246,299 @@ 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();
+    let current_enabled = config
+        .extra
+        .get("browserAutomationEnabled")
+        .and_then(serde_json::Value::as_bool)
+        != Some(false);
+    let current_mode = config
+        .extra
+        .get("browserAgentMode")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("headless");
+    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)"
+    };
+    let width = config
+        .extra
+        .get("browserViewportWidth")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(1440);
+    let height = config
+        .extra
+        .get("browserViewportHeight")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(900);
+    let debug_url = config
+        .extra
+        .get("browserDebugUrl")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("http://127.0.0.1:9222/json/list");
+
+    if raw.is_empty() {
+        return SlashResponse::NeedsChoice {
+            command: "/browser".into(),
+            title: format!(
+                "🌐 Browser Automation Configuration\n• Tools: {}\n• Mode: {}\nSelect an option to configure or run `/browser [on|off|headless|headed|status]`",
+                if current_enabled {
+                    "Enabled (on)"
+                } else {
+                    "Disabled (off)"
+                },
+                if current_mode == "headless" {
+                    "headless Browser"
+                } else {
+                    "headed Automation"
+                }
+            ),
+            options: vec![
+                SlashChoice {
+                    label: format!(
+                        "on — Enable browser automation tools{}",
+                        if current_enabled { " (current)" } else { "" }
+                    ),
+                    value: "on".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "off — Disable browser automation tools{}",
+                        if !current_enabled { " (current)" } else { "" }
+                    ),
+                    value: "off".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "headless Browser — Run silently in background without window{}",
+                        if current_mode == "headless" {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "headless".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "headed Automation — Show browser window on screen{}",
+                        if current_mode == "headed" {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "headed".into(),
+                },
+                SlashChoice {
+                    label: "status — View current configuration & detected Chrome".into(),
+                    value: "status".into(),
+                },
+            ],
+        };
+    }
+
+    let normalized = raw.to_ascii_lowercase();
+    match normalized.as_str() {
+        "status" => SlashResponse::Message {
+            markdown: format!(
+                "### 🌐 Browser Automation Status\n\n\
+                 - **Tools Enabled**: {}\n\
+                 - **Browser Mode**: {}\n\
+                 - **Viewport Size**: `{}` × `{}`\n\
+                 - **Executable**: `{}`\n\
+                 - **Debugging Endpoint**: `{}`\n\n\
+                 *Use `/browser on` or `/browser off` to toggle tools, and `/browser headless` or `/browser headed` to change display mode.*",
+                if current_enabled {
+                    "🟢 **Enabled** (`on`)"
+                } else {
+                    "🔴 **Disabled** (`off`)"
+                },
+                if current_mode == "headless" {
+                    "🕶️ `headless Browser` (runs in background)"
+                } else {
+                    "🖥️ `headed Automation` (shows window)"
+                },
+                width,
+                height,
+                exe_display,
+                debug_url
+            ),
+        },
+        "on" | "enable" => {
+            config
+                .extra
+                .insert("browserAutomationEnabled".into(), serde_json::json!(true));
+            SlashResponse::Applied {
+                markdown: "🟢 **Browser automation tools enabled (`on`)**.\nAgent can inspect web pages and capture screenshots using Headless Chromium.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "off" | "disable" => {
+            config
+                .extra
+                .insert("browserAutomationEnabled".into(), serde_json::json!(false));
+            SlashResponse::Applied {
+                markdown: "🔴 **Browser automation tools disabled (`off`)**.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "headless" | "headless browser" => {
+            config
+                .extra
+                .insert("browserAgentMode".into(), serde_json::json!("headless"));
+            SlashResponse::Applied {
+                markdown: "🕶️ **Browser mode set to `headless Browser`**.\nAutomation will run silently in the background without opening a window.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "headed" | "headed automation" => {
+            config
+                .extra
+                .insert("browserAgentMode".into(), serde_json::json!("headed"));
+            SlashResponse::Applied {
+                markdown: "🖥️ **Browser mode set to `headed Automation`**.\nAutomation will display the browser window on screen in real time.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        _ => SlashResponse::Message {
+            markdown: "Usage: `/browser [on|off|headless|headed|status]`".into(),
+        },
+    }
+}
+
 async fn cmd_temperature_async(rest: &str, config: &mut MintConfig) -> SlashResponse {
     let tokens: Vec<&str> = rest.split_whitespace().collect();
     if tokens.len() == 1 {
@@ -3173,4 +3476,164 @@ 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 NeedsChoice with options
+        match execute(&req("/browser"), &mut cfg) {
+            SlashResponse::NeedsChoice {
+                command, options, ..
+            } => {
+                assert_eq!(command, "/browser");
+                assert!(options.iter().any(|o| o.value == "on"));
+                assert!(options.iter().any(|o| o.value == "off"));
+                assert!(options.iter().any(|o| o.value == "headless"));
+                assert!(options.iter().any(|o| o.value == "headed"));
+                assert!(options.iter().any(|o| o.value == "status"));
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. /browser status returns informative message
+        match execute(&req("/browser status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Browser Automation Status"));
+                assert!(markdown.contains("Enabled"));
+                assert!(markdown.contains("headless Browser"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. /browser off disables tools
+        match execute(&req("/browser off"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAutomationEnabled"),
+                    Some(&serde_json::json!(false))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 4. /browser on re-enables tools
+        match execute(&req("/browser on"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAutomationEnabled"),
+                    Some(&serde_json::json!(true))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 5. /browser headed switches mode
+        match execute(&req("/browser headed"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAgentMode"),
+                    Some(&serde_json::json!("headed"))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 6. /browser headless switches mode back
+        match execute(&req("/browser headless"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAgentMode"),
+                    Some(&serde_json::json!("headless"))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+    }
 }