ReAct Agent API

pub struct ReActAgent {
    llm: Arc<LLMAgent>,
    tools: Arc<RwLock<HashMap<String, Arc<dyn ReActTool>>>>,
    config: ReActConfig,
}

let agent = ReActAgent::builder()
    .with_llm(llm_agent)
    .with_tool(Arc::new(SearchTool))
    .with_max_iterations(5)
    .with_temperature(0.7)
    .build_async()
    .await?;

#[async_trait::async_trait]
pub trait ReActTool: Send + Sync {
    fn name(&self) -> &str;
    fn description(&self) -> &str;
    fn parameters_schema(&self) -> Option<serde_json::Value>;
    async fn execute(&self, input: &str) -> Result<String, String>;
    fn to_llm_tool(&self) -> Tool;
}

use mofa_foundation::react::prelude::*;

let agent = ReActAgent::builder()
    .with_llm(llm_agent)
    .with_tools(all_builtin_tools())
    .build_async()
    .await?;

let (actor_ref, handle) = spawn_react_actor(
    "my-agent",
    llm_agent,
    ReActConfig::default(),
    tools,
).await?;

// Execute task
let result = actor_ref.run_task("What is Rust?").await?;

// Stream steps
let (step_rx, result_rx) = actor_ref.run_task_streaming(task).await?;
while let Some(step) = step_rx.recv().await {
    println!("Step: {:?}", step);
}

// Stop actor
actor_ref.stop()?;

let chain = ChainAgent::new()
    .add("researcher", researcher_agent)
    .add("writer", writer_agent)
    .add("editor", editor_agent)
    .with_transform(|prev_output, next_name| {
        format!("Previous: {}\n\nTask for {}: continue", prev_output, next_name)
    })
    .with_continue_on_error(false)
    .with_verbose(true);

let result = chain.run("Write an article about Rust").await?;

let parallel = ParallelAgent::new()
    .add("expert1", expert1_agent)
    .add("expert2", expert2_agent)
    .add("expert3", expert3_agent)
    .with_aggregation(AggregationStrategy::LLMSummarize(summarizer))
    .with_timeout_ms(30000);

let result = parallel.run("Analyze market trends").await?;

let map_reduce = MapReduceAgent::new()
    .with_mapper(|input| {
        input.lines()
            .map(|line| format!("Process: {}", line))
            .collect()
    })
    .with_worker(worker_agent)
    .with_reducer(reducer_agent)
    .with_concurrency_limit(4);

let result = map_reduce.run("item1\nitem2\nitem3").await?;

let auto_agent = AutoAgent::new(llm_agent.clone(), react_agent)
    .with_auto_mode(true);

// Automatically chooses Direct or ReAct mode based on task complexity
let result = auto_agent.run("What is 2+2?").await?; // Uses Direct
let result = auto_agent.run("Search and analyze data").await?; // Uses ReAct

use mofa_foundation::react::{ReActAgent, ReActTool};
use async_trait::async_trait;
use std::sync::Arc;

// Define custom tool
struct SearchTool;

#[async_trait]
impl ReActTool for SearchTool {
    fn name(&self) -> &str { "search" }
    fn description(&self) -> &str { "Search for information" }
    
    async fn execute(&self, input: &str) -> Result<String, String> {
        Ok(format!("Results for: {}", input))
    }
}

// Create agent
let agent = ReActAgent::builder()
    .with_llm(llm_agent)
    .with_tool(Arc::new(SearchTool))
    .with_max_iterations(5)
    .build_async()
    .await?;

// Execute task
let result = agent.run("Find information about Rust").await?;
println!("Answer: {}", result.answer);

use mofa_foundation::react::patterns::*;

let chain = chain_agents(vec![
    ("researcher", researcher),
    ("writer", writer),
    ("editor", editor),
]);

let result = chain.run("Create article").await?;
println!("Final: {}", result.final_output);

let parallel = parallel_agents_with_summarizer(
    vec![
        ("expert1", expert1),
        ("expert2", expert2),
    ],
    summarizer_llm,
);

let result = parallel.run("Analyze topic").await?;

match agent.run(task).await {
    Ok(result) if result.success => {
        println!("Success: {}", result.answer);
    }
    Ok(result) => {
        eprintln!("Failed: {:?}", result.error);
    }
    Err(e) => {
        eprintln!("Error: {}", e);
    }
}