Struct ToolRegistry 

pub struct ToolRegistry { /* private fields */ }

A registry for managing a collection of tools.

Implementations

impl ToolRegistry

pub fn new() -> Self

Creates a new ToolRegistry.

pub fn register(&mut self, tool: Box<dyn Tool>)

Registers a tool with the registry.

pub fn get(&self, name: &str) -> Option<&dyn Tool>

Gets a tool from the registry by name.

pub async fn execute(&self, name: &str, args: Value) -> Result<ToolResult>

Executes a tool in the registry by name.

pub fn get_definitions(&self) -> Vec<ToolDefinition>

Gets the definitions of all tools in the registry.

pub fn list_tools(&self) -> Vec<String>

Lists the names of all tools in the registry.

Examples found in repository

examples/agent_with_tools.rs (line 25)

async fn main() -> helios_engine::Result<()> {
    // Load configuration from `config.toml`.
    let config = Config::from_file("config.toml")?;

    // Create an agent named "ToolAgent" and equip it with the `CalculatorTool` and `EchoTool`.
    // Using the improved syntax to add multiple tools at once!
    let mut agent = Agent::builder("ToolAgent")
        .config(config)
        .system_prompt("You are a helpful assistant with access to tools. Use them when needed.")
        .tools(vec![Box::new(CalculatorTool), Box::new(EchoTool)])
        .max_iterations(5)
        .build()
        .await?;

    println!(
        "Available tools: {:?}\n",
        agent.tool_registry().list_tools()
    );

    // --- Test the calculator tool ---
    let response = agent.chat("What is 25 * 4 + 10?").await?;
    println!("Agent: {}\n", response);

    // --- Test the echo tool ---
    let response = agent
        .chat("Can you echo this message: 'Hello from Helios!'")
        .await?;
    println!("Agent: {}\n", response);

    Ok(())
}

examples/react_agent.rs (line 37)

async fn main() -> helios_engine::Result<()> {
    println!("🧠 Helios Engine - ReAct Agent Example");
    println!("======================================\n");

    // Load configuration from `config.toml`.
    let config = Config::from_file("config.toml")?;

    // Create an agent with ReAct mode enabled.
    // Notice the simple `.react()` call in the builder pattern!
    let mut agent = Agent::builder("ReActAgent")
        .config(config)
        .system_prompt(
            "You are a helpful assistant that thinks carefully before acting. \
             Use your reasoning to plan your approach.",
        )
        .tools(vec![
            Box::new(CalculatorTool),
            Box::new(EchoTool),
            Box::new(FileReadTool),
        ])
        .react() // Enable ReAct mode - that's all it takes!
        .max_iterations(5)
        .build()
        .await?;

    println!(
        "Available tools: {:?}\n",
        agent.tool_registry().list_tools()
    );

    println!("═══════════════════════════════════════════════════════════");
    println!("Example 1: Mathematical Problem");
    println!("═══════════════════════════════════════════════════════════\n");

    // --- Test 1: Math problem requiring reasoning ---
    println!("User: I need to calculate (25 * 4) + (100 / 5). Can you help?\n");
    let response = agent
        .chat("I need to calculate (25 * 4) + (100 / 5). Can you help?")
        .await?;
    println!("\nAgent: {}\n", response);

    println!("═══════════════════════════════════════════════════════════");
    println!("Example 2: Multi-step Task");
    println!("═══════════════════════════════════════════════════════════\n");

    // --- Test 2: Multi-step task ---
    println!("User: First calculate 15 * 7, then echo the result back to me.\n");
    let response = agent
        .chat("First calculate 15 * 7, then echo the result back to me.")
        .await?;
    println!("\nAgent: {}\n", response);

    println!("═══════════════════════════════════════════════════════════");
    println!(" ReAct Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
    println!("\nNotice how the agent:");
    println!("  1. 💭 First reasons about the task");
    println!("  2. 📋 Creates a plan");
    println!("  3. ⚡ Then executes the actions\n");
    println!("This leads to more thoughtful and systematic problem-solving!");

    Ok(())
}

examples/react_debugging.rs (line 41)

async fn main() -> helios_engine::Result<()> {
    println!("🔍 Helios Engine - ReAct for Debugging");
    println!("=======================================\n");

    let config = Config::from_file("config.toml")?;

    // Create a ReAct agent with verbose reasoning
    let debug_prompt = r#"Debug this task step by step. For each step, explain:

1. CURRENT STATE: What information do I have?
2. NEXT ACTION: What should I do next?
3. REASONING: Why is this the right action?
4. EXPECTED RESULT: What should happen?
5. VALIDATION: How will I know if it worked?

Be extremely detailed in your thinking."#;

    let mut debug_agent = Agent::builder("DebugAgent")
        .config(config)
        .system_prompt("You are a debugging assistant who explains every decision.")
        .tools(vec![
            Box::new(CalculatorTool),
            Box::new(JsonParserTool),
            Box::new(FileReadTool),
        ])
        .react_with_prompt(debug_prompt)
        .max_iterations(15) // Allow more iterations for complex debugging
        .build()
        .await?;

    println!(
        "Available tools: {:?}\n",
        debug_agent.tool_registry().list_tools()
    );

    // Scenario 1: Tracing calculation steps
    println!("═══════════════════════════════════════════════════════════");
    println!("Scenario 1: Trace Complex Calculation");
    println!("═══════════════════════════════════════════════════════════\n");

    println!("Problem: Calculate the compound interest formula result");
    println!("Formula: A = P(1 + r)^n where P=1000, r=0.05, n=3\n");

    let response = debug_agent
        .chat("Calculate compound interest: Principal=1000, rate=0.05, time=3 years. Use A = P * (1 + r)^n")
        .await?;
    println!("\nAgent: {}\n", response);

    // Scenario 2: Understanding tool selection
    println!("═══════════════════════════════════════════════════════════");
    println!("Scenario 2: Tool Selection Reasoning");
    println!("═══════════════════════════════════════════════════════════\n");

    println!("Task: Parse JSON and extract a value, then perform calculation\n");

    let response = debug_agent
        .chat(r#"Parse this JSON: {"price": 25.50, "quantity": 4} and calculate the total cost"#)
        .await?;
    println!("\nAgent: {}\n", response);

    // Scenario 3: Error recovery reasoning
    println!("═══════════════════════════════════════════════════════════");
    println!("Scenario 3: Multi-Step Problem Solving");
    println!("═══════════════════════════════════════════════════════════\n");

    println!("Task: Calculate average of a series of operations\n");

    let response = debug_agent
        .chat("Calculate: (10 * 5) + (20 * 3) + (15 * 2), then divide by 3 to get the average")
        .await?;
    println!("\nAgent: {}\n", response);

    // Explanation
    println!("═══════════════════════════════════════════════════════════");
    println!("💡 Debugging Benefits");
    println!("═══════════════════════════════════════════════════════════\n");

    println!("ReAct mode helps you:");
    println!("  1. 🔍 See exactly what the agent is thinking");
    println!("  2. 🎯 Understand why it chose specific tools");
    println!("  3. 📋 Follow the step-by-step execution plan");
    println!("  4. 🐛 Identify where reasoning might go wrong");
    println!("  5. 🔧 Optimize prompts based on visible thinking\n");

    println!("Tips for debugging with ReAct:");
    println!("  • Use detailed custom prompts for more verbose reasoning");
    println!("  • Increase max_iterations for complex tasks");
    println!("  • Watch the '💭 ReAct Reasoning' output carefully");
    println!("  • Compare reasoning across different queries");
    println!("  • Adjust system prompts based on reasoning patterns\n");

    Ok(())
}

examples/react_comparison.rs (line 34)

async fn main() -> helios_engine::Result<()> {
    println!("🔬 Helios Engine - ReAct Comparison Demo");
    println!("=========================================\n");

    let config1 = Config::from_file("config.toml")?;
    let config2 = Config::from_file("config.toml")?;

    // Create two identical agents, one with ReAct and one without
    let mut standard_agent = Agent::builder("StandardAgent")
        .config(config1)
        .system_prompt("You are a helpful assistant with access to tools.")
        .tools(vec![Box::new(CalculatorTool), Box::new(EchoTool)])
        .build()
        .await?;

    let mut react_agent = Agent::builder("ReActAgent")
        .config(config2)
        .system_prompt("You are a helpful assistant with access to tools.")
        .tools(vec![Box::new(CalculatorTool), Box::new(EchoTool)])
        .react() // The only difference!
        .build()
        .await?;

    println!(
        "Tools available: {:?}\n",
        standard_agent.tool_registry().list_tools()
    );

    // Test Case 1: Simple calculation
    println!("═══════════════════════════════════════════════════════════");
    println!("Test Case 1: Simple Mathematical Calculation");
    println!("═══════════════════════════════════════════════════════════\n");

    let query1 = "What is 25 * 8?";
    println!("Query: {}\n", query1);

    println!("--- STANDARD AGENT ---");
    let response1 = standard_agent.chat(query1).await?;
    println!("Response: {}\n", response1);

    println!("--- REACT AGENT ---");
    let response2 = react_agent.chat(query1).await?;
    println!("Response: {}\n", response2);

    // Test Case 2: Multi-step problem
    println!("═══════════════════════════════════════════════════════════");
    println!("Test Case 2: Multi-Step Problem");
    println!("═══════════════════════════════════════════════════════════\n");

    let query2 = "Calculate (15 + 25) * 3, then echo the result";
    println!("Query: {}\n", query2);

    println!("--- STANDARD AGENT ---");
    let response3 = standard_agent.chat(query2).await?;
    println!("Response: {}\n", response3);

    println!("--- REACT AGENT ---");
    let response4 = react_agent.chat(query2).await?;
    println!("Response: {}\n", response4);

    // Test Case 3: Complex multi-tool task
    println!("═══════════════════════════════════════════════════════════");
    println!("Test Case 3: Complex Multi-Tool Task");
    println!("═══════════════════════════════════════════════════════════\n");

    let query3 =
        "First calculate 100 / 4, then multiply that by 3, and finally echo the final answer";
    println!("Query: {}\n", query3);

    println!("--- STANDARD AGENT ---");
    let response5 = standard_agent.chat(query3).await?;
    println!("Response: {}\n", response5);

    println!("--- REACT AGENT ---");
    let response6 = react_agent.chat(query3).await?;
    println!("Response: {}\n", response6);

    // Summary
    println!("═══════════════════════════════════════════════════════════");
    println!("📊 Comparison Summary");
    println!("═══════════════════════════════════════════════════════════\n");

    println!("STANDARD AGENT:");
    println!("  ✓ Faster execution (no reasoning overhead)");
    println!("  ✓ Direct tool usage");
    println!("  ✗ No visible thought process");
    println!("  ✗ May miss planning opportunities\n");

    println!("REACT AGENT:");
    println!("  ✓ Shows reasoning process (💭 ReAct Reasoning)");
    println!("  ✓ Systematic approach to problems");
    println!("  ✓ Better for complex tasks");
    println!("  ✗ Slightly slower (extra LLM call)\n");

    println!("WHEN TO USE:");
    println!("  → Standard: Simple, direct tasks where speed matters");
    println!("  → ReAct: Complex tasks, debugging, when you want transparency\n");

    Ok(())
}

Trait Implementations

impl Default for ToolRegistry

fn default() -> Self

Returns the “default value” for a type.