@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-core/src/prompts/tool_catalog.rs

@@ -12,7 +12,7 @@ use std::path::Path;
 
 use serde_json::{Value, json};
 
-use super::agent::{PLAN_MODE_ALLOWED_ACTIONS, base_allowed_actions, browser_endpoint_available};
+use super::agent::{PLAN_MODE_ALLOWED_ACTIONS, base_allowed_actions};
 use crate::MintConfig;
 use crate::chat::ToolSpec;
 use crate::subagents::list_subagents;
@@ -34,15 +34,14 @@ fn tool(name: &str, description: &str, parameters: Value) -> ToolSpec {
 }
 
 /// Builds the native tool-calling catalog for the current request: the set of
-/// actions available given `config.disabled_tools`, whether the automation
-/// browser is reachable on port 9222, and whether plan mode is active (which
+/// actions available given `config.disabled_tools`, whether browser automation is enabled, and whether plan mode is active (which
 /// restricts to investigation-only actions plus `exit_plan_mode`).
 ///
 /// Mirrors the exact filtering `build_system_prompt` applies to
 /// `base_allowed_actions`, so the two code paths can never offer a different
 /// set of tools for the same request.
 ///
-/// `dispatch_subagent` is deliberately **not** part of `base_allowed_actions`
+/// `dispatch_agents` is deliberately **not** part of `base_allowed_actions`
 /// (which also drives the legacy JSON-prompt path) — it's native-tool-calling
 /// only, same scoping as context compaction. `allow_subagent_dispatch` should
 /// be `false` when building the catalog for a subagent's own nested loop, so
@@ -55,9 +54,6 @@ pub fn tool_catalog(
     allow_subagent_dispatch: bool,
 ) -> Vec<ToolSpec> {
     let mut allowed = base_allowed_actions();
-    if browser_endpoint_available(config) {
-        allowed.extend_from_slice(crate::browser::BROWSER_TOOLS);
-    }
     if !config.avatar_token.is_empty() && !config.avatar_signal_disabled {
         allowed.push("avatar_signal");
     }
@@ -79,37 +75,86 @@ pub fn tool_catalog(
     // and can be streamed as the final answer.
     tools.push(finish_tool());
 
-    if allow_subagent_dispatch && !plan_mode {
+    if allow_subagent_dispatch {
         let subagents = list_subagents(Some(root));
-        if !subagents.is_empty() {
-            tools.push(dispatch_subagent_tool(&subagents));
+        let available_subagents: Vec<_> = if plan_mode {
+            subagents
+                .into_iter()
+                .filter(|s| {
+                    let perms = crate::swarm::AgentPermissions::from_tools(s.tools.as_deref());
+                    !perms.is_write_capable()
+                })
+                .collect()
+        } else {
+            subagents
+        };
+        if !available_subagents.is_empty() {
+            tools.push(dispatch_agents_tool(&available_subagents, plan_mode));
         }
     }
 
+    if let Some(permissions) = crate::swarm::current_permissions() {
+        tools.retain(|t| permissions.allows(&t.name));
+    }
+
     tools
 }
 
-fn dispatch_subagent_tool(subagents: &[crate::subagents::SubagentDefinition]) -> ToolSpec {
+fn dispatch_agents_tool(
+    subagents: &[crate::subagents::SubagentDefinition],
+    plan_mode: bool,
+) -> ToolSpec {
     let names: Vec<String> = subagents.iter().map(|s| s.name.clone()).collect();
     let catalog_text = subagents
         .iter()
         .map(|s| format!("- {}: {}", s.name, s.description))
         .collect::<Vec<_>>()
         .join("\n");
+    let description = if plan_mode {
+        format!(
+            "Delegate exploratory reconnaissance tasks to isolated, read-only sub-agents running \
+             concurrently in their own contexts to investigate across files, trace flows, or verify \
+             system facts before creating the plan. In plan mode, all subagents run strictly read-only.\n\
+             Available read-only base profiles (defaults to 'explorer'):\n{catalog_text}"
+        )
+    } else {
+        format!(
+            "Delegate one or more focused tasks to isolated sub-agents that run concurrently in \
+             their own contexts and return capped dossiers — use this to investigate across files, \
+             trace flows, or check hypotheses without polluting your main context.\n\
+             Base profiles decide the permissions of each agent (defaults to 'explorer'):\n{catalog_text}"
+        )
+    };
     tool(
-        "dispatch_subagent",
-        &format!(
-            "Delegate a focused sub-task to a specialized subagent that runs in its own \
-             isolated context and returns only its final result — use this to investigate \
-             something without filling up your own context with the intermediate steps. \
-             Available subagents:\n{catalog_text}"
-        ),
+        "dispatch_agents",
+        &description,
         schema(
             json!({
-                "name": { "type": "string", "enum": names, "description": "Which subagent to dispatch." },
-                "instruction": { "type": "string", "description": "The task/question to give the subagent." }
+                "tasks": {
+                    "type": "array",
+                    "description": "List of tasks to run concurrently in isolated sub-agents.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "role": {
+                                "type": "string",
+                                "description": "Display label and focus for this agent (e.g. 'stripe-webhook-tracer')."
+                            },
+                            "base": {
+                                "type": "string",
+                                "enum": names,
+                                "description": "Profile deciding permissions. Defaults to 'explorer' (read-only)."
+                            },
+                            "instruction": {
+                                "type": "string",
+                                "description": "The task, research question, or command to execute."
+                            }
+                        },
+                        "required": ["instruction"]
+                    }
+                }
             }),
-            &["name", "instruction"],
+            &["tasks"],
         ),
     )
 }
@@ -126,7 +171,11 @@ fn finish_tool() -> ToolSpec {
                 },
                 "verification": {
                     "type": "string",
-                    "description": "Verification performed after file changes and its result; otherwise omit."
+                    "description": "Observed check results, or the reason completion is limited. Prose cannot override actual execution evidence."
+                },
+                "completionStatus": {
+                    "type": "string", "enum": ["verified", "unverified", "blocked", "failed"],
+                    "description": "Use verified only with actual evidence. Use unverified/blocked/failed and explain limitations in verification."
                 }
             }),
             &["summary"],
@@ -162,16 +211,6 @@ fn all_tools() -> Vec<ToolSpec> {
                 &["arguments"],
             ),
         ),
-        tool(
-            "conversation_summary",
-            "Internal tool representing a compacted conversation history summary from previous steps.",
-            schema(
-                json!({
-                    "summary": { "type": "string", "description": "Compacted summary text." }
-                }),
-                &[],
-            ),
-        ),
         tool(
             "list_files",
             "List files and directories under a workspace path, ~/path, or an allowed user folder (Downloads, Documents, Desktop, Pictures, Music, Videos).",
@@ -314,118 +353,6 @@ fn all_tools() -> Vec<ToolSpec> {
                 &["expression"],
             ),
         ),
-        tool(
-            "browser_open",
-            "Navigate the automation browser to a URL.",
-            schema(json!({ "url": { "type": "string" } }), &["url"]),
-        ),
-        tool(
-            "browser_click",
-            "Click an observed element. Provide elementRef or selector, not both.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_type",
-            "Append text to a field. Provide elementRef or selector, not both.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"text":{"type":"string"}}),
-                &["text"],
-            ),
-        ),
-        tool(
-            "browser_fill",
-            "Replace a field's value and verify it.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"text":{"type":"string"}}),
-                &["text"],
-            ),
-        ),
-        tool(
-            "browser_select",
-            "Select a native dropdown option by value.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"value":{"type":"string"}}),
-                &["value"],
-            ),
-        ),
-        tool(
-            "browser_observe",
-            "Read structured page state and fresh element references. Confirm takeover only after the user has completed it.",
-            schema(
-                json!({"textOffset":{"type":"integer","minimum":0},"elementOffset":{"type":"integer","minimum":0},"takeoverComplete":{"type":"boolean"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_tabs",
-            "List/open/select/close tabs. Selection and closure require explicit tabId; popups are never auto-selected.",
-            schema(
-                json!({"operation":{"type":"string","enum":["list","open","select","close"]},"tabId":{"type":"string"},"url":{"type":"string"}}),
-                &["operation"],
-            ),
-        ),
-        tool(
-            "browser_scroll",
-            "Scroll the viewport or an observed element by pixels.",
-            schema(
-                json!({"elementRef":{"type":"string"},"selector":{"type":"string"},"x":{"type":"number"},"y":{"type":"number"}}),
-                &[],
-            ),
-        ),
-        tool(
-            "browser_wait",
-            "Wait for a URL, text, or element visibility condition; at most 30 seconds.",
-            schema(
-                json!({"condition":{"type":"string","enum":["url","text","visible","hidden"]},"value":{"type":"string"},"elementRef":{"type":"string"},"selector":{"type":"string"},"timeoutMs":{"type":"integer","minimum":1,"maximum":30000}}),
-                &["condition"],
-            ),
-        ),
-        tool(
-            "browser_read",
-            "Read the text content of the active browser page.",
-            schema(json!({}), &[]),
-        ),
-        tool(
-            "browser_mouse_move",
-            "Move the browser cursor to viewport (x, y) coordinates.",
-            schema(
-                json!({ "x": { "type": "number" }, "y": { "type": "number" } }),
-                &["x", "y"],
-            ),
-        ),
-        tool(
-            "browser_mouse_click",
-            "Perform a native mouse click at (x, y). Use browser_screenshot first to find the target position.",
-            schema(
-                json!({
-                    "x": { "type": "number" },
-                    "y": { "type": "number" },
-                    "button": { "type": "string", "description": "left | right | middle. Defaults to left." }
-                }),
-                &["x", "y"],
-            ),
-        ),
-        tool(
-            "browser_key_press",
-            "Press a keyboard key in the automation browser.",
-            schema(
-                json!({
-                    "key": {
-                        "type": "string",
-                        "description": "Enter, Tab, Escape, Backspace, Delete, ArrowUp/Down/Left/Right, F1-F12, Space, ..."
-                    }
-                }),
-                &["key"],
-            ),
-        ),
-        tool(
-            "browser_screenshot",
-            "Capture the current automation browser page as an image.",
-            schema(json!({}), &[]),
-        ),
         tool(
             "memory_recall",
             "Search past interactions/memory before asking the user to repeat context.",
@@ -560,7 +487,7 @@ fn all_tools() -> Vec<ToolSpec> {
         ),
         tool(
             "ask_user",
-            "Ask the user a short question, optionally with up to 3 pick-a-choice options (each with an optional description), optionally allowing multiple selections, and optionally tagged with a short header label. The user can still answer freely. Use this tool only when you're blocked on a decision that is genuinely the user's to make — one you can't resolve from the request, the code, or a sensible default. Don't use it to ask for permission to proceed or to confirm something you can just go do.",
+            "Ask the user a short question, optionally with up to 3 pick-a-choice options (each with an optional description), optionally allowing multiple selections, and optionally tagged with a short header label. The user can still answer freely. Use this tool when you need the user's direction, or after proposing a plan/recommendation to ask how they want to proceed before mutating code. Avoid using it for trivial micro-steps that the user already explicitly authorized.",
             schema(
                 json!({
                     "query": { "type": "string" },
@@ -605,8 +532,11 @@ fn all_tools() -> Vec<ToolSpec> {
         ),
         tool(
             "view_image",
-            "View an image file from the workspace.",
-            schema(json!({ "path": { "type": "string" } }), &["path"]),
+            "View an image from the workspace using path, or reopen an image artifact from this conversation using artifactId.",
+            schema(
+                json!({ "path": { "type": "string" }, "artifactId":{"type":"string"} }),
+                &[],
+            ),
         ),
         tool(
             "search_docs",
@@ -687,6 +617,7 @@ fn all_tools() -> Vec<ToolSpec> {
             schema(
                 json!({
                     "command": { "type": "string" },
+                    "retryReason": { "type": "string", "description": "Reason for retrying a previous command. Inspect running/unknown results before repeating side effects." },
                     "background": {
                         "type": "boolean",
                         "description": "Run detached and return immediately with a job_id instead of waiting for the command to exit. Defaults to false."
@@ -1048,6 +979,24 @@ fn all_tools() -> Vec<ToolSpec> {
     ]
 }
 
+#[cfg(test)]
+mod browser_startup_tests {
+    use super::*;
+    #[test]
+    fn browser_tools_are_superseded_by_shell_playbook() {
+        let config = MintConfig::default();
+        let default_tools = tool_catalog(&config, false, Path::new("."), false);
+        // Agent browser_* tools are removed; web browsing is done via run_shell
+        assert!(!default_tools.iter().any(|tool| tool.name == "browser_open"));
+        assert!(
+            !default_tools
+                .iter()
+                .any(|tool| tool.name == "browser_screenshot")
+        );
+        assert!(default_tools.iter().any(|tool| tool.name == "run_shell"));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1130,7 +1079,7 @@ mod tests {
     }
 
     #[test]
-    fn dispatch_subagent_offered_only_when_allowed_and_subagents_exist() {
+    fn dispatch_agents_offered_only_when_allowed_and_subagents_exist() {
         let root = std::env::temp_dir().join("mint-tool-catalog-subagents");
         let _ = std::fs::remove_dir_all(&root);
         write_subagent(
@@ -1147,20 +1096,22 @@ mod tests {
         let _ = std::fs::remove_dir_all(&empty_root);
         std::fs::create_dir_all(&empty_root).unwrap();
         let tools = tool_catalog(&config, false, &empty_root, true);
-        assert!(tools.iter().any(|t| t.name == "dispatch_subagent"));
+        assert!(tools.iter().any(|t| t.name == "dispatch_agents"));
 
         // Subagents exist + allowed -> offered.
         let tools = tool_catalog(&config, false, &root, true);
-        assert!(tools.iter().any(|t| t.name == "dispatch_subagent"));
+        assert!(tools.iter().any(|t| t.name == "dispatch_agents"));
 
         // Subagents exist but not allowed (this is itself a nested subagent
         // call) -> the depth-limit enforcement, never offered.
         let tools = tool_catalog(&config, false, &root, false);
-        assert!(!tools.iter().any(|t| t.name == "dispatch_subagent"));
+        assert!(!tools.iter().any(|t| t.name == "dispatch_agents"));
 
-        // Subagents exist but plan mode is active -> never offered either.
+        // Subagents exist and plan mode is active -> offered with read-only profiles only!
         let tools = tool_catalog(&config, true, &root, true);
-        assert!(!tools.iter().any(|t| t.name == "dispatch_subagent"));
+        let plan_dispatch = tools.iter().find(|t| t.name == "dispatch_agents");
+        assert!(plan_dispatch.is_some());
+        assert!(plan_dispatch.unwrap().description.contains("read-only"));
 
         let _ = std::fs::remove_dir_all(&root);
         let _ = std::fs::remove_dir_all(&empty_root);

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

@@ -108,6 +108,17 @@ pub fn resolve_readable_path(target: &str, workspace: Option<&Path>) -> PathBuf
                 candidates.push(ws.join(&norm_slash));
             }
             candidates.push(ws.join(trimmed));
+
+            // Defensively recover from duplicated workspace prefixes (e.g. /workspace/workspace/file)
+            let ws_norm = ws.to_string_lossy().replace('\\', "/");
+            let ws_clean = ws_norm.trim_end_matches('/');
+            if let Some(rest) = norm_slash.strip_prefix(ws_clean) {
+                let inner = rest.trim_start_matches('/');
+                if !inner.is_empty() {
+                    candidates.push(PathBuf::from(format!("/{}", inner)));
+                    candidates.push(PathBuf::from(inner));
+                }
+            }
         }
     }
 
@@ -304,6 +315,15 @@ mod tests {
         let resolved_win = resolve_readable_path("sub\\sample.md", Some(&temp_dir));
         assert_eq!(resolved_win, test_file);
 
+        // Duplicated workspace prefix recovery
+        let duplicated = format!(
+            "{}/{}",
+            temp_dir.to_string_lossy(),
+            test_file.to_string_lossy().trim_start_matches('/')
+        );
+        let resolved_dup = resolve_readable_path(&duplicated, Some(&temp_dir));
+        assert_eq!(resolved_dup, test_file);
+
         // Non-existent path returns fallback joined with workspace
         let missing = resolve_readable_path("missing.md", Some(&temp_dir));
         assert_eq!(missing, temp_dir.join("missing.md"));

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);
+    }
 }