@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/orchestration/tools/shell.rs

@@ -2,6 +2,40 @@ use std::path::Path;
 
 use super::super::*;
 
+/// Catch ordinary URL launcher commands, not arbitrary shell programs. This is
+/// a workflow guard, not a shell security boundary.
+fn launches_external_url(command: &str) -> bool {
+    let Some(tokens) = shlex::split(command) else {
+        return false;
+    };
+    let Some(program) = tokens.first() else {
+        return false;
+    };
+    let program = program.rsplit(['/', '\\']).next().unwrap_or(program);
+    let launcher = match program.to_ascii_lowercase().as_str() {
+        "xdg-open" | "open" | "wslview" | "sensible-browser" | "start-process" | "start" => true,
+        "gio" => tokens.get(1).is_some_and(|arg| arg == "open"),
+        _ => false,
+    };
+    launcher
+        && tokens.iter().skip(1).any(|arg| {
+            reqwest::Url::parse(arg).is_ok_and(|url| {
+                matches!(url.scheme(), "http" | "https") && url.host_str().is_some()
+            })
+        })
+}
+
+pub(in crate::orchestration) async fn prevent_duplicate_browser_launch(
+    command: &str,
+) -> Result<(), OrchestrationError> {
+    if launches_external_url(command) && crate::browser::session_finish_evidence().await {
+        return Err(OrchestrationError::Agent(
+            "External URL launch skipped: this task already uses the automation browser. Use browser_observe/browser_read to inspect its current page, browser_screenshot for visual inspection, or browser_open if navigation is still needed. Do not open the same URL in another browser.".into(),
+        ));
+    }
+    Ok(())
+}
+
 /// Handles the subset of `execute_tool` actions related to shell.
 /// Only called for actions `execute_tool` has already routed here, so the
 /// fallback arm is unreachable in practice.
@@ -16,6 +50,7 @@ pub(in crate::orchestration) async fn execute(
     match action {
         "run_shell" => {
             let command = required(&input.command, "command")?;
+            prevent_duplicate_browser_launch(command).await?;
             let mode = classify_shell_command(command).mode.as_str().to_owned();
             let approved = approve_cb(&AgentApproval::RunShell {
                 command: command.to_owned(),
@@ -26,8 +61,21 @@ pub(in crate::orchestration) async fn execute(
 
             match approved {
                 ApprovalOutcome::Approved if input.background => {
-                    let started = crate::bg_shell::start_background(root, config, command)
-                        .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+                    if let Err(reason) = reliability::before_shell(command, &input.retry_reason) {
+                        return Ok(format!("Skipped: {reason}"));
+                    }
+                    let started = crate::bg_shell::with_context(
+                        crate::bg_shell::chat_context(root, chat_id),
+                        || crate::bg_shell::start_background(root, config, command),
+                    )
+                    .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+                    reliability::record(
+                        command,
+                        reliability::ExecutionState::Running,
+                        None,
+                        Some(started.id.clone()),
+                        "",
+                    );
                     Ok(format!(
                         "job_id: {}\npid: {}\nstatus: running\nUse the 'shell_output' tool with this job_id to check on it, and 'kill_shell' to stop it.",
                         started.id,
@@ -36,18 +84,39 @@ pub(in crate::orchestration) async fn execute(
                             .map_or_else(|| "unknown".to_string(), |p| p.to_string()),
                     ))
                 }
-                ApprovalOutcome::Approved => run_shell(root, config, chat_id, command).await,
+                ApprovalOutcome::Approved => {
+                    run_shell(root, config, chat_id, command, &input.retry_reason).await
+                }
                 ApprovalOutcome::Denied => Ok(format!("User denied shell command: {}", command)),
                 ApprovalOutcome::Intercepted(obs) => Ok(obs),
             }
         }
         "shell_output" => {
             let job_id = required(&input.job_id, "job_id")?;
+            if !crate::bg_shell::accessible(
+                job_id,
+                &crate::bg_shell::chat_context(root, chat_id).owner,
+            ) {
+                return Err(OrchestrationError::Agent(
+                    "No accessible background job with that id".into(),
+                ));
+            }
+            let snapshot = crate::bg_shell::snapshot(job_id)
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            reliability::record_job(&snapshot);
             crate::bg_shell::poll_output(job_id)
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))
         }
         "kill_shell" => {
             let job_id = required(&input.job_id, "job_id")?;
+            if !crate::bg_shell::accessible(
+                job_id,
+                &crate::bg_shell::chat_context(root, chat_id).owner,
+            ) {
+                return Err(OrchestrationError::Agent(
+                    "No accessible background job with that id".into(),
+                ));
+            }
             crate::bg_shell::kill_job(job_id).map_err(|e| OrchestrationError::Agent(e.to_string()))
         }
         "verify" => {
@@ -58,7 +127,7 @@ pub(in crate::orchestration) async fn execute(
             }
             let mut output = Vec::new();
             for command in &input.commands {
-                output.push(run_shell(root, config, chat_id, command).await?);
+                output.push(run_shell(root, config, chat_id, command, &input.retry_reason).await?);
             }
             Ok(output.join("\n\n"))
         }
@@ -93,7 +162,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [TEST FAILED]"
@@ -123,7 +195,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [TYPECHECK FAILED]"
@@ -149,7 +224,10 @@ pub(in crate::orchestration) async fn execute(
                 ));
             };
 
-            let out = run_shell(root, config, chat_id, &cmd).await?;
+            let out = run_shell(root, config, chat_id, &cmd, &input.retry_reason).await?;
+            if out.starts_with("Skipped") {
+                return Ok(out);
+            }
             let failed = shell_result_failed(&out);
             let status_mark = if failed {
                 "✗ [LINT FAILED]"
@@ -163,3 +241,42 @@ pub(in crate::orchestration) async fn execute(
         ),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn external_url_launch_detection_preserves_other_shell_work() {
+        for command in [
+            "xdg-open 'https://example.com/watch?v=1&list=2'",
+            "/usr/bin/xdg-open https://example.com &",
+            "open -a Firefox https://example.com",
+            "gio open https://example.com",
+            "wslview https://example.com",
+            "Start-Process https://example.com",
+        ] {
+            assert!(launches_external_url(command), "{command}");
+        }
+        for command in [
+            "xdg-open /tmp/report.pdf",
+            "open /tmp",
+            "curl https://example.com",
+            "echo xdg-open https://example.com",
+            "gio info https://example.com",
+            "cargo test",
+        ] {
+            assert!(!launches_external_url(command), "{command}");
+        }
+    }
+
+    #[tokio::test]
+    async fn external_url_launch_allowed_without_browser_use() {
+        crate::browser::run_session(async {
+            prevent_duplicate_browser_launch("xdg-open https://example.com")
+                .await
+                .unwrap();
+        })
+        .await;
+    }
+}

package/crates/mint-core/src/orchestration/tools/web.rs

@@ -46,7 +46,11 @@ pub(in crate::orchestration) async fn execute(
                                 let image_line = h
                                     .image_url
                                     .as_deref()
-                                    .map(|img| format!("   Image: {img}\n"))
+                                    .map(|img| {
+                                        let normalized =
+                                            crate::web_search::normalize_web_search_image_url(img);
+                                        format!("   Image: {normalized}\n")
+                                    })
                                     .unwrap_or_default();
                                 format!(
                                     "{}. {}\n   URL: {}\n{}{}\n",

package/crates/mint-core/src/orchestration/trajectory_schema.rs

@@ -0,0 +1,353 @@
+//! Standardized Trajectory Schema v1.0
+//!
+//! Provides a typed, versioned schema for agent execution trajectories compliant with
+//! SWE-bench and OpenTelemetry / Agent Protocol standards. Facilitates deterministic
+//! session replays, benchmark evaluations, and multi-platform telemetry export.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use super::AgentProgress;
+
+/// Token usage metadata for an individual trajectory step.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct StepTokens {
+    #[serde(default)]
+    pub input_tokens: u64,
+    #[serde(default)]
+    pub generated_tokens: u64,
+}
+
+/// A discrete, typed execution step within an agent run.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct StandardTrajectoryStep {
+    /// 1-based step counter
+    pub step: usize,
+    /// RFC3339 timestamp of step completion
+    pub timestamp: String,
+    /// Model reasoning or thought preceding action
+    pub thought: String,
+    /// Tool or action invoked (e.g. "apply_patch", "run_shell", "finish")
+    pub action: String,
+    /// Canonical JSON arguments supplied to the action
+    pub input: Value,
+    /// Observation returned by environment / harness
+    pub observation: String,
+    /// Step outcome status ("success", "failed", "intercepted", "skipped")
+    pub status: String,
+    /// Wall-clock execution duration in milliseconds
+    pub duration_ms: u64,
+    /// Step token metrics
+    pub tokens: StepTokens,
+}
+
+/// Complete execution trajectory for an agent run, compliant with SWE-bench & Agent Protocol v1.0.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct StandardTrajectoryRun {
+    /// Schema version, e.g. "1.0"
+    pub schema_version: String,
+    /// Unique identifier for this run
+    pub run_id: String,
+    /// Chat session identifier
+    pub chat_id: String,
+    /// High-level user prompt or task specification
+    pub task: String,
+    /// Active model name
+    pub model: String,
+    /// Model provider name
+    pub provider: String,
+    /// RFC3339 timestamp when run started
+    pub started_at: String,
+    /// RFC3339 timestamp when run finished
+    pub completed_at: String,
+    /// Final status outcome ("SUCCESS", "VERIFIED", "PARTIAL", "FAILED", "ROLLED_BACK")
+    pub outcome: String,
+    /// Total number of steps executed
+    pub total_steps: usize,
+    /// Total tokens consumed across all steps
+    pub total_tokens: u64,
+    /// Wall-clock duration in seconds
+    pub duration_secs: f64,
+    /// List of file paths created during the run
+    pub files_created: Vec<String>,
+    /// List of file paths modified during the run
+    pub files_modified: Vec<String>,
+    /// Chronological list of steps executed
+    pub trajectory: Vec<StandardTrajectoryStep>,
+}
+
+impl StandardTrajectoryRun {
+    /// Initializes a new StandardTrajectoryRun with default 1.0 schema version.
+    pub fn new(
+        run_id: impl Into<String>,
+        chat_id: impl Into<String>,
+        task: impl Into<String>,
+        model: impl Into<String>,
+        provider: impl Into<String>,
+    ) -> Self {
+        let now = chrono::Utc::now().to_rfc3339();
+        Self {
+            schema_version: "1.0".to_string(),
+            run_id: run_id.into(),
+            chat_id: chat_id.into(),
+            task: task.into(),
+            model: model.into(),
+            provider: provider.into(),
+            started_at: now.clone(),
+            completed_at: now,
+            outcome: "PENDING".to_string(),
+            total_steps: 0,
+            total_tokens: 0,
+            duration_secs: 0.0,
+            files_created: Vec::new(),
+            files_modified: Vec::new(),
+            trajectory: Vec::new(),
+        }
+    }
+
+    /// Records an executed trajectory step and updates total_steps.
+    pub fn record_step(&mut self, step: StandardTrajectoryStep) {
+        self.trajectory.push(step);
+        self.total_steps = self.trajectory.len();
+    }
+
+    /// Finalizes the trajectory run metadata upon completion.
+    pub fn finish(
+        &mut self,
+        outcome: impl Into<String>,
+        total_tokens: u64,
+        duration_secs: f64,
+        files_created: Vec<String>,
+        files_modified: Vec<String>,
+    ) {
+        self.outcome = outcome.into();
+        self.total_tokens = total_tokens;
+        self.duration_secs = duration_secs;
+        self.files_created = files_created;
+        self.files_modified = files_modified;
+        self.completed_at = chrono::Utc::now().to_rfc3339();
+        self.total_steps = self.trajectory.len();
+    }
+
+    /// Serializes the run into SWE-bench compliant pretty-printed JSON.
+    pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(self)
+    }
+
+    /// Deserializes a run from JSON.
+    pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
+        serde_json::from_str(json)
+    }
+
+    /// Reconstructs a `StandardTrajectoryRun` from an event stream (`AgentProgress`).
+    /// Useful for historical runs or external consumers where only events were preserved.
+    pub fn from_agent_activity(
+        chat_id: &str,
+        run_id: &str,
+        task: &str,
+        model: &str,
+        provider: &str,
+        events: &[AgentProgress],
+    ) -> Self {
+        // First check if a RunCompleted event already has an embedded trajectory
+        for event in events {
+            if let AgentProgress::RunCompleted { summary } = event {
+                if let Some(existing) = &summary.trajectory {
+                    return existing.clone();
+                }
+            }
+        }
+
+        let mut run = Self::new(run_id, chat_id, task, model, provider);
+        let mut latest_thought = String::new();
+        let mut step_counter = 1;
+
+        for event in events {
+            match event {
+                AgentProgress::Thought { thought } => {
+                    latest_thought = thought.clone();
+                }
+                AgentProgress::ExtendedThinking { thought, .. } => {
+                    latest_thought = thought.clone();
+                }
+                AgentProgress::ToolEnd {
+                    action,
+                    input,
+                    result,
+                    elapsed_ms,
+                    status,
+                    ..
+                } => {
+                    let status_str = match status {
+                        Some(crate::integrations::mcp_result::ToolStatus::Success) => "success",
+                        Some(crate::integrations::mcp_result::ToolStatus::Failed) => "failed",
+                        Some(crate::integrations::mcp_result::ToolStatus::TimedOut) => "timed_out",
+                        Some(crate::integrations::mcp_result::ToolStatus::Cancelled) => "cancelled",
+                        Some(crate::integrations::mcp_result::ToolStatus::Skipped) => "skipped",
+                        _ => {
+                            if result.starts_with("Error") || result.contains("failed") {
+                                "failed"
+                            } else {
+                                "success"
+                            }
+                        }
+                    };
+
+                    run.record_step(StandardTrajectoryStep {
+                        step: step_counter,
+                        timestamp: chrono::Utc::now().to_rfc3339(),
+                        thought: std::mem::take(&mut latest_thought),
+                        action: action.clone(),
+                        input: input.clone(),
+                        observation: result.clone(),
+                        status: status_str.to_string(),
+                        duration_ms: elapsed_ms.unwrap_or(0),
+                        tokens: StepTokens::default(),
+                    });
+                    step_counter += 1;
+                }
+                AgentProgress::RunCompleted { summary } => {
+                    if !summary.run_id.is_empty() {
+                        run.run_id = summary.run_id.clone();
+                    }
+                    if !summary.task.is_empty() {
+                        run.task = summary.task.clone();
+                    }
+                    run.finish(
+                        &summary.outcome,
+                        summary.total_tokens as u64,
+                        summary.duration_secs,
+                        summary.files_created.clone(),
+                        summary.files_changed.clone(),
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        run
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn serializes_canonical_v1_schema() {
+        let mut run = StandardTrajectoryRun::new(
+            "run-101",
+            "chat-abc",
+            "Fix bug in parser",
+            "claude-3-7-sonnet",
+            "anthropic",
+        );
+        run.record_step(StandardTrajectoryStep {
+            step: 1,
+            timestamp: "2026-10-26T12:00:00Z".to_string(),
+            thought: "I need to inspect the parser code".to_string(),
+            action: "read_file".to_string(),
+            input: json!({"path": "src/parser.rs"}),
+            observation: "pub fn parse() {}".to_string(),
+            status: "success".to_string(),
+            duration_ms: 125,
+            tokens: StepTokens {
+                input_tokens: 1500,
+                generated_tokens: 65,
+            },
+        });
+        run.finish(
+            "SUCCESS",
+            1565,
+            2.5,
+            vec![],
+            vec!["src/parser.rs".to_string()],
+        );
+
+        let json = run.to_json_pretty().expect("must serialize");
+        assert!(json.contains("\"schemaVersion\": \"1.0\""));
+        assert!(json.contains("\"runId\": \"run-101\""));
+        assert!(json.contains("\"chatId\": \"chat-abc\""));
+        assert!(json.contains("\"inputTokens\": 1500"));
+        assert!(json.contains("\"durationMs\": 125"));
+        assert!(json.contains("\"outcome\": \"SUCCESS\""));
+    }
+
+    #[test]
+    fn roundtrip_json_parity() {
+        let mut run =
+            StandardTrajectoryRun::new("run-202", "chat-xyz", "Add feature", "gpt-4o", "openai");
+        run.record_step(StandardTrajectoryStep {
+            step: 1,
+            timestamp: "2026-10-26T12:01:00Z".to_string(),
+            thought: "Checking dir".to_string(),
+            action: "list_files".to_string(),
+            input: json!({"path": "."}),
+            observation: "Cargo.toml\nsrc/".to_string(),
+            status: "success".to_string(),
+            duration_ms: 42,
+            tokens: StepTokens::default(),
+        });
+        run.finish("VERIFIED", 300, 1.2, vec!["Cargo.toml".to_string()], vec![]);
+
+        let json_str = run.to_json_pretty().expect("must serialize");
+        let parsed = StandardTrajectoryRun::from_json(&json_str).expect("must deserialize");
+        assert_eq!(run, parsed);
+    }
+
+    #[test]
+    fn reconstructs_from_agent_activity() {
+        let events = vec![
+            AgentProgress::Thought {
+                thought: "Locating function".to_string(),
+            },
+            AgentProgress::ToolEnd {
+                call_id: Some("call-1".to_string()),
+                action: "grep".to_string(),
+                input: json!({"query": "fn test"}),
+                result: "src/lib.rs:10: fn test()".to_string(),
+                status: Some(crate::integrations::mcp_result::ToolStatus::Success),
+                elapsed_ms: Some(85),
+                subagent: None,
+            },
+            AgentProgress::RunCompleted {
+                summary: crate::orchestration::RunTelemetrySummary {
+                    run_id: "run-303".to_string(),
+                    task: "Find function".to_string(),
+                    outcome: "SUCCESS".to_string(),
+                    total_tokens: 1200,
+                    tool_calls_count: 1,
+                    files_changed: vec![],
+                    files_created: vec![],
+                    duration_secs: 1.5,
+                    tool_timeline: vec![],
+                    retries_count: 0,
+                    trajectory: None,
+                },
+            },
+        ];
+
+        let run = StandardTrajectoryRun::from_agent_activity(
+            "chat-999",
+            "run-303",
+            "Find function",
+            "gemini-2.5-pro",
+            "google",
+            &events,
+        );
+
+        assert_eq!(run.schema_version, "1.0");
+        assert_eq!(run.run_id, "run-303");
+        assert_eq!(run.chat_id, "chat-999");
+        assert_eq!(run.outcome, "SUCCESS");
+        assert_eq!(run.total_steps, 1);
+        assert_eq!(run.trajectory[0].action, "grep");
+        assert_eq!(run.trajectory[0].thought, "Locating function");
+        assert_eq!(run.trajectory[0].duration_ms, 85);
+        assert_eq!(run.trajectory[0].status, "success");
+    }
+}