@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/tools/mod.rs

@@ -0,0 +1,295 @@
+//! Tools module for SWE-agent
+//!
+//! This module provides tool handling, command parsing, and action processing.
+
+pub mod bundle;
+pub mod commands;
+pub mod parsing;
+pub mod registry;
+
+pub use bundle::*;
+pub use commands::*;
+pub use parsing::*;
+pub use registry::*;
+
+use crate::environment::SWEEnv;
+use crate::exceptions::Result;
+use crate::types::ModelOutput;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Configuration for tool filtering
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ToolFilterConfig {
+    #[serde(default)]
+    pub blocklist_error_template: String,
+    #[serde(default)]
+    pub blocklist: Vec<String>,
+    #[serde(default)]
+    pub blocklist_standalone: Vec<String>,
+    #[serde(default)]
+    pub block_unless_regex: HashMap<String, String>,
+}
+
+/// Configuration for tools
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolConfig {
+    #[serde(default)]
+    pub commands: Vec<BundleConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parse_function: Option<ParseFunctionConfig>,
+    #[serde(default = "default_execution_timeout")]
+    pub execution_timeout: u64,
+    #[serde(default = "default_max_consecutive_timeouts")]
+    pub max_consecutive_execution_timeouts: usize,
+    #[serde(default = "default_total_execution_timeout")]
+    pub total_execution_timeout: u64,
+    #[serde(default = "default_submit_command")]
+    pub submit_command: String,
+    #[serde(default)]
+    pub use_function_calling: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub filter: Option<ToolFilterConfig>,
+    #[serde(default = "default_format_error_template")]
+    pub format_error_template: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub command_docs: Option<String>,
+    #[serde(default)]
+    pub env_variables: HashMap<String, String>,
+}
+
+fn default_execution_timeout() -> u64 {
+    500
+}
+
+fn default_max_consecutive_timeouts() -> usize {
+    3
+}
+
+fn default_total_execution_timeout() -> u64 {
+    7200
+}
+
+fn default_submit_command() -> String {
+    "submit".to_string()
+}
+
+fn default_format_error_template() -> String {
+    "Invalid format. Please use the correct format for actions.".to_string()
+}
+
+impl Default for ToolConfig {
+    fn default() -> Self {
+        Self {
+            commands: Vec::new(),
+            parse_function: None,
+            execution_timeout: default_execution_timeout(),
+            max_consecutive_execution_timeouts: default_max_consecutive_timeouts(),
+            total_execution_timeout: default_total_execution_timeout(),
+            submit_command: default_submit_command(),
+            use_function_calling: false,
+            filter: None,
+            format_error_template: default_format_error_template(),
+            command_docs: None,
+            env_variables: HashMap::new(),
+        }
+    }
+}
+
+/// Tool handler for managing agent tools
+pub struct ToolHandler {
+    pub config: ToolConfig,
+    bundles: Vec<Bundle>,
+    parser: Box<dyn ParseFunction>,
+    multiline_commands: HashMap<String, String>,
+}
+
+impl ToolHandler {
+    pub fn new(config: ToolConfig) -> Result<Self> {
+        let bundles: Vec<Bundle> = config
+            .commands
+            .iter()
+            .map(create_bundle)
+            .collect::<Result<Vec<_>>>()?;
+
+        let parser = config
+            .parse_function
+            .as_ref()
+            .map(create_parser)
+            .unwrap_or_else(|| Box::new(ThoughtActionParser::new()));
+
+        let mut multiline_commands = HashMap::new();
+        for bundle in &bundles {
+            if let Some(ref end_name) = bundle.end_name {
+                multiline_commands.insert(bundle.name.clone(), end_name.clone());
+            }
+        }
+
+        Ok(Self {
+            config,
+            bundles,
+            parser,
+            multiline_commands,
+        })
+    }
+
+    /// Install tools in the environment
+    pub async fn install(&self, env: &mut SWEEnv) -> Result<()> {
+        // Set environment variables
+        if !self.config.env_variables.is_empty() {
+            env.set_env_variables(self.config.env_variables.clone())
+                .await?;
+        }
+
+        // Install each bundle
+        let cwd = env.communicate("pwd", Some(5)).await?;
+
+        for bundle in &self.bundles {
+            if let Some(ref install_script) = bundle.install_script {
+                env.communicate(install_script, Some(300)).await?;
+            }
+        }
+
+        // Return to original directory
+        env.communicate(&format!("cd {}", cwd.trim()), Some(5))
+            .await?;
+
+        Ok(())
+    }
+
+    /// Get current state from environment
+    pub async fn get_state(&self, env: &SWEEnv) -> HashMap<String, String> {
+        let mut state = HashMap::new();
+
+        if let Some(cwd) = env.get_cwd() {
+            state.insert("working_dir".to_string(), cwd);
+        }
+
+        let open_files = env.get_open_files();
+        if !open_files.is_empty() {
+            state.insert("open_files".to_string(), open_files.join(", "));
+        }
+
+        if let Ok(git_status) = env.get_git_status().await {
+            state.insert("git_status".to_string(), git_status);
+        }
+
+        state
+    }
+
+    /// Parse thought and action from model output
+    pub fn parse_actions(&self, output: &ModelOutput) -> Result<(String, String)> {
+        self.parser.parse(&output.message, &self.bundles, true)
+    }
+
+    /// Check if an action should be blocked
+    pub fn should_block_action(&self, action: &str) -> bool {
+        let action = action.trim();
+        if action.is_empty() {
+            return false;
+        }
+
+        if let Some(ref filter) = self.config.filter {
+            // Check blocklist
+            for blocked in &filter.blocklist {
+                if action.starts_with(blocked) {
+                    return true;
+                }
+            }
+
+            // Check standalone blocklist
+            if filter.blocklist_standalone.contains(&action.to_string()) {
+                return true;
+            }
+
+            // Check block unless regex
+            let command_name = action.split_whitespace().next().unwrap_or("");
+            if let Some(pattern) = filter.block_unless_regex.get(command_name) {
+                if let Ok(re) = Regex::new(pattern) {
+                    if !re.is_match(action) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Check if observation contains submission command
+    pub fn check_for_submission_cmd(&self, observation: &str) -> bool {
+        observation.contains(crate::exceptions::tokens::SUBMISSION_MARKER)
+    }
+
+    /// Guard multiline input with heredoc syntax
+    pub fn guard_multiline_input(&self, action: &str) -> String {
+        for (cmd_name, end_name) in &self.multiline_commands {
+            let pattern = format!(r"^{}\b", regex::escape(cmd_name));
+            if let Ok(re) = Regex::new(&pattern) {
+                if re.is_match(action) {
+                    // Check if already has heredoc syntax
+                    if !action.contains("<<") {
+                        let lines: Vec<&str> = action.lines().collect();
+                        if lines.len() > 1 {
+                            let mut guarded_lines = Vec::new();
+                            guarded_lines.push(format!("{} << '{}'", lines[0], end_name));
+                            guarded_lines.extend(lines[1..].iter().map(|s| s.to_string()));
+                            guarded_lines.push(end_name.clone());
+                            return guarded_lines.join("\n");
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        action.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tool_handler_creation() {
+        let config = ToolConfig::default();
+        let handler = ToolHandler::new(config).unwrap();
+        assert!(!handler.should_block_action("ls -la"));
+    }
+
+    #[test]
+    fn test_should_block_action() {
+        let config = ToolConfig {
+            filter: Some(ToolFilterConfig {
+                blocklist: vec!["rm -rf".to_string()],
+                blocklist_standalone: vec!["exit".to_string()],
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        let handler = ToolHandler::new(config).unwrap();
+
+        assert!(handler.should_block_action("rm -rf /"));
+        assert!(!handler.should_block_action("rm file.txt"));
+    }
+
+    #[test]
+    fn test_guard_multiline_input() {
+        let config = ToolConfig {
+            commands: vec![BundleConfig {
+                name: "edit".to_string(),
+                end_name: Some("ENDEDIT".to_string()),
+                ..Default::default()
+            }],
+            ..Default::default()
+        };
+        let handler = ToolHandler::new(config).unwrap();
+
+        let multiline = "edit file.txt\nline1\nline2";
+        let guarded = handler.guard_multiline_input(multiline);
+        assert!(guarded.contains("<<"));
+        assert!(guarded.contains("ENDEDIT"));
+    }
+}

package/rust/src/tools/parsing.rs

@@ -0,0 +1,354 @@
+//! Action parsing implementations
+
+use super::Bundle;
+use crate::exceptions::{Result, SWEAgentError};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+/// Trait for parsing model output into thought and action
+pub trait ParseFunction: Send + Sync {
+    fn parse(&self, output: &str, bundles: &[Bundle], strict: bool) -> Result<(String, String)>;
+}
+
+/// Thought and action parser (default)
+pub struct ThoughtActionParser {
+    thought_pattern: Regex,
+    action_pattern: Regex,
+}
+
+impl ThoughtActionParser {
+    pub fn new() -> Self {
+        Self {
+            thought_pattern: Regex::new(r"(?s)^(.*?)```").unwrap(),
+            action_pattern: Regex::new(r"(?s)```(?:\w+)?\n?(.*?)```").unwrap(),
+        }
+    }
+}
+
+impl Default for ThoughtActionParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for ThoughtActionParser {
+    fn parse(&self, output: &str, _bundles: &[Bundle], strict: bool) -> Result<(String, String)> {
+        // Extract thought (everything before the code block)
+        let thought = self
+            .thought_pattern
+            .captures(output)
+            .and_then(|c| c.get(1))
+            .map(|m| m.as_str().trim().to_string())
+            .unwrap_or_default();
+
+        // Extract action (content of the code block)
+        let action = self
+            .action_pattern
+            .captures(output)
+            .and_then(|c| c.get(1))
+            .map(|m| m.as_str().trim().to_string());
+
+        match action {
+            Some(a) => Ok((thought, a)),
+            None => {
+                if strict {
+                    Err(SWEAgentError::FormatError(
+                        "Could not find action in code block".to_string(),
+                    ))
+                } else {
+                    Ok((output.to_string(), String::new()))
+                }
+            }
+        }
+    }
+}
+
+/// Action-only parser (no thought required)
+pub struct ActionOnlyParser {
+    action_pattern: Regex,
+}
+
+impl ActionOnlyParser {
+    pub fn new() -> Self {
+        Self {
+            action_pattern: Regex::new(r"(?s)```(?:\w+)?\n?(.*?)```").unwrap(),
+        }
+    }
+}
+
+impl Default for ActionOnlyParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for ActionOnlyParser {
+    fn parse(&self, output: &str, _bundles: &[Bundle], strict: bool) -> Result<(String, String)> {
+        let action = self
+            .action_pattern
+            .captures(output)
+            .and_then(|c| c.get(1))
+            .map(|m| m.as_str().trim().to_string());
+
+        match action {
+            Some(a) => Ok((String::new(), a)),
+            None => {
+                if strict {
+                    Err(SWEAgentError::FormatError(
+                        "Could not find action in code block".to_string(),
+                    ))
+                } else {
+                    // Treat the entire output as the action
+                    Ok((String::new(), output.trim().to_string()))
+                }
+            }
+        }
+    }
+}
+
+/// XML-style thought action parser
+pub struct XmlThoughtActionParser {
+    thought_pattern: Regex,
+    action_pattern: Regex,
+}
+
+impl XmlThoughtActionParser {
+    pub fn new() -> Self {
+        Self {
+            thought_pattern: Regex::new(r"(?s)<thought>(.*?)</thought>").unwrap(),
+            action_pattern: Regex::new(r"(?s)<action>(.*?)</action>").unwrap(),
+        }
+    }
+}
+
+impl Default for XmlThoughtActionParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for XmlThoughtActionParser {
+    fn parse(&self, output: &str, _bundles: &[Bundle], strict: bool) -> Result<(String, String)> {
+        let thought = self
+            .thought_pattern
+            .captures(output)
+            .and_then(|c| c.get(1))
+            .map(|m| m.as_str().trim().to_string())
+            .unwrap_or_default();
+
+        let action = self
+            .action_pattern
+            .captures(output)
+            .and_then(|c| c.get(1))
+            .map(|m| m.as_str().trim().to_string());
+
+        match action {
+            Some(a) => Ok((thought, a)),
+            None => {
+                if strict {
+                    Err(SWEAgentError::FormatError(
+                        "Could not find action in <action> tags".to_string(),
+                    ))
+                } else {
+                    Ok((output.to_string(), String::new()))
+                }
+            }
+        }
+    }
+}
+
+/// Function calling parser for OpenAI-style function calls
+pub struct FunctionCallingParser;
+
+impl FunctionCallingParser {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for FunctionCallingParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for FunctionCallingParser {
+    fn parse(&self, output: &str, bundles: &[Bundle], strict: bool) -> Result<(String, String)> {
+        // For function calling, we expect the output to be JSON or contain tool calls
+        // This is a simplified implementation
+
+        // Try to parse as JSON tool call
+        if let Ok(json) = serde_json::from_str::<serde_json::Value>(output) {
+            if let Some(name) = json.get("name").and_then(|n| n.as_str()) {
+                let args = json
+                    .get("arguments")
+                    .map(|a| a.to_string())
+                    .unwrap_or_default();
+                return Ok((String::new(), format!("{} {}", name, args)));
+            }
+        }
+
+        // Fall back to thought action parsing
+        ThoughtActionParser::new().parse(output, bundles, strict)
+    }
+}
+
+/// JSON parser for structured output
+pub struct JsonParser;
+
+impl JsonParser {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for JsonParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for JsonParser {
+    fn parse(&self, output: &str, _bundles: &[Bundle], strict: bool) -> Result<(String, String)> {
+        // Try to find JSON in the output
+        let json_pattern = Regex::new(r"(?s)\{.*\}").unwrap();
+
+        if let Some(json_match) = json_pattern.find(output) {
+            let json_str = json_match.as_str();
+            if let Ok(json) = serde_json::from_str::<serde_json::Value>(json_str) {
+                let thought = json
+                    .get("thought")
+                    .and_then(|t| t.as_str())
+                    .unwrap_or("")
+                    .to_string();
+                let action = json
+                    .get("action")
+                    .and_then(|a| a.as_str())
+                    .unwrap_or("")
+                    .to_string();
+                return Ok((thought, action));
+            }
+        }
+
+        if strict {
+            Err(SWEAgentError::FormatError(
+                "Could not parse JSON output".to_string(),
+            ))
+        } else {
+            Ok((output.to_string(), String::new()))
+        }
+    }
+}
+
+/// Identity parser that returns output as-is
+pub struct IdentityParser;
+
+impl IdentityParser {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for IdentityParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ParseFunction for IdentityParser {
+    fn parse(&self, output: &str, _bundles: &[Bundle], _strict: bool) -> Result<(String, String)> {
+        Ok((String::new(), output.to_string()))
+    }
+}
+
+/// Configuration for parse functions
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ParseFunctionConfig {
+    #[default]
+    ThoughtAction,
+    ActionOnly,
+    XmlThoughtAction,
+    FunctionCalling,
+    Json,
+    Identity,
+}
+
+/// Create a parser from configuration
+pub fn create_parser(config: &ParseFunctionConfig) -> Box<dyn ParseFunction> {
+    match config {
+        ParseFunctionConfig::ThoughtAction => Box::new(ThoughtActionParser::new()),
+        ParseFunctionConfig::ActionOnly => Box::new(ActionOnlyParser::new()),
+        ParseFunctionConfig::XmlThoughtAction => Box::new(XmlThoughtActionParser::new()),
+        ParseFunctionConfig::FunctionCalling => Box::new(FunctionCallingParser::new()),
+        ParseFunctionConfig::Json => Box::new(JsonParser::new()),
+        ParseFunctionConfig::Identity => Box::new(IdentityParser::new()),
+    }
+}
+
+/// Get a parser by name string
+pub fn get_parser(name: &str) -> Box<dyn ParseFunction> {
+    match name {
+        "thought_action" => Box::new(ThoughtActionParser::new()),
+        "action_only" => Box::new(ActionOnlyParser::new()),
+        "xml_thought_action" => Box::new(XmlThoughtActionParser::new()),
+        "function_calling" => Box::new(FunctionCallingParser::new()),
+        "json" => Box::new(JsonParser::new()),
+        "identity" => Box::new(IdentityParser::new()),
+        _ => Box::new(ThoughtActionParser::new()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_thought_action_parser() {
+        let parser = ThoughtActionParser::new();
+        let output = "Let me check the file.\n\n```\ncat file.txt\n```";
+        let (thought, action) = parser.parse(output, &[], true).unwrap();
+
+        assert_eq!(thought, "Let me check the file.");
+        assert_eq!(action, "cat file.txt");
+    }
+
+    #[test]
+    fn test_action_only_parser() {
+        let parser = ActionOnlyParser::new();
+        let output = "```bash\nls -la\n```";
+        let (thought, action) = parser.parse(output, &[], true).unwrap();
+
+        assert_eq!(thought, "");
+        assert_eq!(action, "ls -la");
+    }
+
+    #[test]
+    fn test_xml_parser() {
+        let parser = XmlThoughtActionParser::new();
+        let output = "<thought>Checking files</thought><action>ls</action>";
+        let (thought, action) = parser.parse(output, &[], true).unwrap();
+
+        assert_eq!(thought, "Checking files");
+        assert_eq!(action, "ls");
+    }
+
+    #[test]
+    fn test_strict_mode_failure() {
+        let parser = ThoughtActionParser::new();
+        let output = "No code block here";
+        let result = parser.parse(output, &[], true);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_non_strict_mode() {
+        let parser = ThoughtActionParser::new();
+        let output = "No code block here";
+        let (thought, action) = parser.parse(output, &[], false).unwrap();
+
+        assert_eq!(thought, "No code block here");
+        assert_eq!(action, "");
+    }
+}