@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/agent/history_processors.rs

@@ -0,0 +1,277 @@
+//! History processors for managing conversation history
+//!
+//! These processors transform the conversation history before it's sent to the model.
+
+use crate::types::{Content, History};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+/// Trait for history processors
+pub trait HistoryProcessor: Send + Sync {
+    fn process(&self, history: History) -> History;
+}
+
+/// Default history processor that passes through unchanged
+pub struct DefaultHistoryProcessor;
+
+impl HistoryProcessor for DefaultHistoryProcessor {
+    fn process(&self, history: History) -> History {
+        history
+    }
+}
+
+/// Processor that keeps only the last N observations
+pub struct LastNObservations {
+    n: usize,
+}
+
+impl LastNObservations {
+    pub fn new(n: usize) -> Self {
+        Self { n }
+    }
+}
+
+impl HistoryProcessor for LastNObservations {
+    fn process(&self, history: History) -> History {
+        if self.n == 0 {
+            return history;
+        }
+
+        let mut result = Vec::new();
+        let mut observation_count = 0;
+
+        // Iterate in reverse to count observations from the end
+        for item in history.iter().rev() {
+            let is_observation = item
+                .message_type
+                .as_ref()
+                .map(|t| matches!(t, crate::types::MessageType::Observation))
+                .unwrap_or(false);
+
+            if is_observation {
+                observation_count += 1;
+            }
+
+            if observation_count <= self.n || !is_observation {
+                result.push(item.clone());
+            }
+        }
+
+        result.reverse();
+        result
+    }
+}
+
+/// Processor that wraps tool call observations in tags
+pub struct TagToolCallObservations {
+    tag: String,
+}
+
+impl TagToolCallObservations {
+    pub fn new(tag: impl Into<String>) -> Self {
+        Self { tag: tag.into() }
+    }
+}
+
+impl HistoryProcessor for TagToolCallObservations {
+    fn process(&self, history: History) -> History {
+        history
+            .into_iter()
+            .map(|mut item| {
+                if item.tool_call_ids.is_some() {
+                    let content = item.content.as_str();
+                    item.content =
+                        Content::Text(format!("<{}>\n{}\n</{}>", self.tag, content, self.tag));
+                }
+                item
+            })
+            .collect()
+    }
+}
+
+/// Processor that handles closed window files
+pub struct ClosedWindowHistoryProcessor;
+
+impl HistoryProcessor for ClosedWindowHistoryProcessor {
+    fn process(&self, history: History) -> History {
+        // Implementation would track open/closed files and adjust history
+        history
+    }
+}
+
+/// Processor that adds cache control headers for Anthropic
+pub struct CacheControlHistoryProcessor;
+
+impl HistoryProcessor for CacheControlHistoryProcessor {
+    fn process(&self, history: History) -> History {
+        // Add cache control for last few messages
+        history
+    }
+}
+
+/// Processor that removes content matching a regex pattern
+pub struct RemoveRegex {
+    pattern: Regex,
+}
+
+impl RemoveRegex {
+    pub fn new(pattern: &str) -> Option<Self> {
+        Regex::new(pattern).ok().map(|pattern| Self { pattern })
+    }
+}
+
+impl HistoryProcessor for RemoveRegex {
+    fn process(&self, history: History) -> History {
+        history
+            .into_iter()
+            .map(|mut item| {
+                let content = item.content.as_str();
+                let cleaned = self.pattern.replace_all(&content, "").to_string();
+                item.content = Content::Text(cleaned);
+                item
+            })
+            .collect()
+    }
+}
+
+/// Processor that handles image parsing in history
+pub struct ImageParsingHistoryProcessor {
+    disable_images: bool,
+}
+
+impl ImageParsingHistoryProcessor {
+    pub fn new(disable_images: bool) -> Self {
+        Self { disable_images }
+    }
+}
+
+impl HistoryProcessor for ImageParsingHistoryProcessor {
+    fn process(&self, history: History) -> History {
+        if !self.disable_images {
+            return history;
+        }
+
+        // Remove image content parts
+        history
+            .into_iter()
+            .map(|mut item| {
+                if let Content::Structured(parts) = &item.content {
+                    let filtered: Vec<_> = parts
+                        .iter()
+                        .filter(|p| !matches!(p, crate::types::ContentPart::Image { .. }))
+                        .cloned()
+                        .collect();
+                    item.content = Content::Structured(filtered);
+                }
+                item
+            })
+            .collect()
+    }
+}
+
+/// Chain multiple history processors together
+pub struct ChainedHistoryProcessor {
+    processors: Vec<Box<dyn HistoryProcessor>>,
+}
+
+impl ChainedHistoryProcessor {
+    pub fn new(processors: Vec<Box<dyn HistoryProcessor>>) -> Self {
+        Self { processors }
+    }
+}
+
+impl HistoryProcessor for ChainedHistoryProcessor {
+    fn process(&self, mut history: History) -> History {
+        for processor in &self.processors {
+            history = processor.process(history);
+        }
+        history
+    }
+}
+
+/// Configuration for history processors
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum HistoryProcessorConfig {
+    #[default]
+    Default,
+    LastNObservations { n: usize },
+    TagToolCallObservations { tag: String },
+    ClosedWindow,
+    CacheControl,
+    RemoveRegex { pattern: String },
+    ImageParsing { disable_images: bool },
+}
+
+/// Create a history processor from configuration
+pub fn create_history_processor(config: &HistoryProcessorConfig) -> Box<dyn HistoryProcessor> {
+    match config {
+        HistoryProcessorConfig::Default => Box::new(DefaultHistoryProcessor),
+        HistoryProcessorConfig::LastNObservations { n } => Box::new(LastNObservations::new(*n)),
+        HistoryProcessorConfig::TagToolCallObservations { tag } => {
+            Box::new(TagToolCallObservations::new(tag))
+        }
+        HistoryProcessorConfig::ClosedWindow => Box::new(ClosedWindowHistoryProcessor),
+        HistoryProcessorConfig::CacheControl => Box::new(CacheControlHistoryProcessor),
+        HistoryProcessorConfig::RemoveRegex { pattern } => RemoveRegex::new(pattern)
+            .map(|p| Box::new(p) as Box<dyn HistoryProcessor>)
+            .unwrap_or_else(|| Box::new(DefaultHistoryProcessor)),
+        HistoryProcessorConfig::ImageParsing { disable_images } => {
+            Box::new(ImageParsingHistoryProcessor::new(*disable_images))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::{HistoryItem, MessageType, Role};
+
+    #[test]
+    fn test_default_processor() {
+        let processor = DefaultHistoryProcessor;
+        let history = vec![HistoryItem::user("test")];
+        let result = processor.process(history.clone());
+        assert_eq!(result.len(), history.len());
+    }
+
+    #[test]
+    fn test_last_n_observations() {
+        let processor = LastNObservations::new(2);
+        let history = vec![
+            HistoryItem {
+                role: Role::User,
+                content: Content::Text("obs1".to_string()),
+                message_type: Some(MessageType::Observation),
+                ..Default::default()
+            },
+            HistoryItem {
+                role: Role::User,
+                content: Content::Text("obs2".to_string()),
+                message_type: Some(MessageType::Observation),
+                ..Default::default()
+            },
+            HistoryItem {
+                role: Role::User,
+                content: Content::Text("obs3".to_string()),
+                message_type: Some(MessageType::Observation),
+                ..Default::default()
+            },
+        ];
+
+        let result = processor.process(history);
+        assert_eq!(result.len(), 2);
+    }
+
+    #[test]
+    fn test_remove_regex() {
+        let processor = RemoveRegex::new(r"\[DEBUG\]").unwrap();
+        let history = vec![HistoryItem {
+            content: Content::Text("Hello [DEBUG] world".to_string()),
+            ..Default::default()
+        }];
+
+        let result = processor.process(history);
+        assert_eq!(result[0].content.as_str(), "Hello  world");
+    }
+}

package/rust/src/agent/hooks/mod.rs

@@ -0,0 +1,208 @@
+//! Agent hooks for monitoring and extending agent behavior
+
+use crate::types::{AgentInfo, History, StepOutput, Trajectory};
+use async_trait::async_trait;
+
+/// Abstract hook for agent events
+#[async_trait]
+pub trait AgentHook: Send + Sync {
+    /// Called when agent is initialized
+    fn on_init(&mut self, _agent: &dyn std::any::Any) {}
+
+    /// Called when tools installation starts
+    fn on_tools_installation_started(&mut self) {}
+
+    /// Called when setup attempt begins
+    fn on_setup_attempt(&mut self) {}
+
+    /// Called when setup is complete
+    fn on_setup_done(&mut self) {}
+
+    /// Called when a query message is added to history
+    fn on_query_message_added(&mut self, _message: &QueryMessageEvent) {}
+
+    /// Called when model is queried
+    fn on_model_query(&mut self, _history: &History, _agent_name: &str) {}
+
+    /// Called when actions are generated
+    fn on_actions_generated(&mut self, _step: &StepOutput) {}
+
+    /// Called when action execution starts
+    fn on_action_started(&mut self, _step: &StepOutput) {}
+
+    /// Called when action execution completes
+    fn on_action_executed(&mut self, _step: &StepOutput) {}
+
+    /// Called when a step starts
+    fn on_step_start(&mut self) {}
+
+    /// Called when a step completes
+    fn on_step_done(&mut self, _step: &StepOutput, _info: &AgentInfo) {}
+
+    /// Called when a run starts
+    fn on_run_start(&mut self) {}
+
+    /// Called when a run completes
+    fn on_run_done(&mut self, _trajectory: &Trajectory, _info: &AgentInfo) {}
+}
+
+/// Event data for query message added
+#[derive(Debug, Clone)]
+pub struct QueryMessageEvent {
+    pub agent: String,
+    pub role: String,
+    pub content: String,
+    pub message_type: String,
+    pub is_demo: Option<bool>,
+    pub thought: Option<String>,
+    pub action: Option<String>,
+}
+
+/// Combined hook that wraps multiple hooks
+pub struct CombinedAgentHook {
+    hooks: Vec<Box<dyn AgentHook>>,
+}
+
+impl CombinedAgentHook {
+    pub fn new() -> Self {
+        Self { hooks: Vec::new() }
+    }
+
+    pub fn add_hook(&mut self, hook: Box<dyn AgentHook>) {
+        self.hooks.push(hook);
+    }
+}
+
+impl Default for CombinedAgentHook {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl AgentHook for CombinedAgentHook {
+    fn on_init(&mut self, agent: &dyn std::any::Any) {
+        for hook in &mut self.hooks {
+            hook.on_init(agent);
+        }
+    }
+
+    fn on_tools_installation_started(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_tools_installation_started();
+        }
+    }
+
+    fn on_setup_attempt(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_setup_attempt();
+        }
+    }
+
+    fn on_setup_done(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_setup_done();
+        }
+    }
+
+    fn on_query_message_added(&mut self, message: &QueryMessageEvent) {
+        for hook in &mut self.hooks {
+            hook.on_query_message_added(message);
+        }
+    }
+
+    fn on_model_query(&mut self, history: &History, agent_name: &str) {
+        for hook in &mut self.hooks {
+            hook.on_model_query(history, agent_name);
+        }
+    }
+
+    fn on_actions_generated(&mut self, step: &StepOutput) {
+        for hook in &mut self.hooks {
+            hook.on_actions_generated(step);
+        }
+    }
+
+    fn on_action_started(&mut self, step: &StepOutput) {
+        for hook in &mut self.hooks {
+            hook.on_action_started(step);
+        }
+    }
+
+    fn on_action_executed(&mut self, step: &StepOutput) {
+        for hook in &mut self.hooks {
+            hook.on_action_executed(step);
+        }
+    }
+
+    fn on_step_start(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_step_start();
+        }
+    }
+
+    fn on_step_done(&mut self, step: &StepOutput, info: &AgentInfo) {
+        for hook in &mut self.hooks {
+            hook.on_step_done(step, info);
+        }
+    }
+
+    fn on_run_start(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_run_start();
+        }
+    }
+
+    fn on_run_done(&mut self, trajectory: &Trajectory, info: &AgentInfo) {
+        for hook in &mut self.hooks {
+            hook.on_run_done(trajectory, info);
+        }
+    }
+}
+
+/// Status hook that logs agent progress
+pub struct StatusHook {
+    pub show_progress: bool,
+}
+
+impl StatusHook {
+    pub fn new(show_progress: bool) -> Self {
+        Self { show_progress }
+    }
+}
+
+impl Default for StatusHook {
+    fn default() -> Self {
+        Self::new(true)
+    }
+}
+
+#[async_trait]
+impl AgentHook for StatusHook {
+    fn on_step_start(&mut self) {
+        if self.show_progress {
+            tracing::info!("Step started");
+        }
+    }
+
+    fn on_step_done(&mut self, step: &StepOutput, _info: &AgentInfo) {
+        if self.show_progress {
+            tracing::info!(
+                done = step.done,
+                exit_status = ?step.exit_status,
+                "Step completed"
+            );
+        }
+    }
+
+    fn on_run_done(&mut self, trajectory: &Trajectory, info: &AgentInfo) {
+        if self.show_progress {
+            tracing::info!(
+                steps = trajectory.len(),
+                submission = ?info.submission,
+                exit_status = ?info.exit_status,
+                "Run completed"
+            );
+        }
+    }
+}

package/rust/src/agent/mod.rs

@@ -0,0 +1,24 @@
+//! Agent module for SWE-agent
+//!
+//! This module contains the core agent implementations including:
+//! - `DefaultAgent` - The main agent implementation
+//! - `RetryAgent` - An agent that retries with different configurations
+//! - Various model implementations for LLM interaction
+//! - History processors for managing conversation history
+//! - Problem statement handling
+
+pub mod action_sampler;
+pub mod agents;
+pub mod history_processors;
+pub mod hooks;
+pub mod models;
+pub mod problem_statement;
+pub mod reviewer;
+
+pub use action_sampler::*;
+pub use agents::*;
+pub use history_processors::*;
+pub use hooks::*;
+pub use models::*;
+pub use problem_statement::*;
+pub use reviewer::*;