Struct ForestBuilder 

pub struct ForestBuilder { /* private fields */ }

Builder for creating a Forest of Agents with multiple agents.

Implementations

impl ForestBuilder

pub fn new() -> Self

Creates a new ForestBuilder.

Examples found in repository

examples/send_message_tool_demo.rs (line 28)

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

    // Load configuration
    let config = Config::from_file("config.toml")?;
    println!("✓ Loaded configuration from config.toml");

    // Create a simple forest with two agents
    let mut forest = ForestBuilder::new()
        .config(config)
        .agent(
            "alice".to_string(),
            Agent::builder("alice")
                .system_prompt("You are Alice, a helpful communication assistant."),
        )
        .agent(
            "bob".to_string(),
            Agent::builder("bob")
                .system_prompt("You are Bob, a friendly colleague who responds to messages."),
        )
        .max_iterations(3)
        .build()
        .await?;

    println!("✓ Created Forest with 2 agents: Alice and Bob");
    println!();

    // Demonstrate SendMessageTool direct messaging
    println!("📤 Testing SendMessageTool - Direct Message:");
    println!("---------------------------------------------");

    // Create the tool for Alice
    let message_queue = Arc::new(RwLock::new(Vec::new()));
    let shared_context = Arc::new(RwLock::new(helios_engine::SharedContext::new()));

    let send_tool = SendMessageTool::new(
        "alice".to_string(),
        Arc::clone(&message_queue),
        Arc::clone(&shared_context),
    );

    // Test 1: Send a direct message from Alice to Bob
    println!("1. Alice sends a direct message to Bob...");

    let direct_message_args = serde_json::json!({
        "to": "bob",
        "message": "Hi Bob! How are you doing today?"
    });

    let result = send_tool.execute(direct_message_args).await?;
    println!("   Tool result: {}", result.output);
    println!("   Success: {}", result.success);

    // Check the message queue
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.first() {
            println!("   Message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    // Check shared context
    {
        let context = shared_context.read().await;
        let messages = context.get_recent_messages(10);
        println!("   Messages in shared context: {}", messages.len());
    }

    println!();

    // Test 2: Send a broadcast message
    println!("2. Alice broadcasts a message to everyone...");

    let broadcast_message_args = serde_json::json!({
        "message": "Hello everyone! This is a broadcast message from Alice."
    });

    let result2 = send_tool.execute(broadcast_message_args).await?;
    println!("   Tool result: {}", result2.output);
    println!("   Success: {}", result2.success);

    // Check the message queue after broadcast
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.last() {
            println!("   Latest message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    println!();

    // Demonstrate integration with Forest messaging system
    println!("🌲 Testing Forest Integration:");
    println!("------------------------------");

    // Clear our test queues and use the forest's messaging system
    {
        let mut queue = message_queue.write().await;
        queue.clear();
    }

    println!("3. Using Forest's messaging system...");

    // Send message through the forest
    forest
        .send_message(
            &"alice".to_string(),
            Some(&"bob".to_string()),
            "Hello Bob via Forest messaging!".to_string(),
        )
        .await?;

    // Process messages
    forest.process_messages().await?;

    // Check if Bob received the message
    if let Some(bob) = forest.get_agent(&"bob".to_string()) {
        let messages = bob.chat_session().messages.clone();
        println!("   Bob's message count: {}", messages.len());
        if let Some(last_msg) = messages.last() {
            println!("   Bob received: {}", last_msg.content);
        }
    }

    println!();

    // Test broadcast through forest
    println!("4. Forest broadcast message...");

    forest
        .send_message(
            &"alice".to_string(),
            None, // Broadcast
            "Forest broadcast: Meeting at 3 PM!".to_string(),
        )
        .await?;

    forest.process_messages().await?;

    // Check all agents received the broadcast
    for agent_id in ["alice", "bob"] {
        if let Some(agent) = forest.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") || last_msg.content.contains("Meeting") {
                    println!("   {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    println!();
    println!("✅ SendMessageTool demo completed successfully!");
    println!();
    println!("Key features tested:");
    println!("  • Direct messaging between agents");
    println!("  • Broadcast messaging to all agents");
    println!("  • Message queue management");
    println!("  • Shared context integration");
    println!("  • Forest messaging system integration");

    Ok(())
}

examples/forest_of_agents.rs (line 25)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Forest of Agents Demo");
    println!("=========================================\n");

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

    // Create a Forest of Agents with specialized agents
    let mut forest = ForestBuilder::new()
        .config(config)
        // Coordinator agent - manages the team and delegates tasks
        .agent(
            "coordinator".to_string(),
            Agent::builder("coordinator")
                .system_prompt(
                    "You are a project coordinator responsible for breaking down complex tasks \
                    and delegating them to specialized team members. You communicate with other \
                    agents to ensure the project is completed successfully. Use the available \
                    communication tools to delegate tasks, share information, and coordinate work."
                )
        )
        // Research agent - gathers and analyzes information
        .agent(
            "researcher".to_string(),
            Agent::builder("researcher")
                .system_prompt(
                    "You are a research specialist who excels at gathering information, \
                    analyzing data, and providing insights. You work closely with the coordinator \
                    and writer to ensure all work is based on accurate information. Use \
                    communication tools to share your findings and request clarification when needed."
                )
        )
        // Writer agent - creates content and documentation
        .agent(
            "writer".to_string(),
            Agent::builder("writer")
                .system_prompt(
                    "You are a skilled writer who creates clear, well-structured content and \
                    documentation. You work with the coordinator and researcher to produce \
                    high-quality written materials. Use communication tools to request information \
                    from the researcher and coordinate with the coordinator on project requirements."
                )
        )
        .max_iterations(5)
        .build()
        .await?;

    println!("✓ Created Forest of Agents with 3 specialized agents:");
    println!("  • Coordinator: Manages projects and delegates tasks");
    println!("  • Researcher: Gathers and analyzes information");
    println!("  • Writer: Creates content and documentation");
    println!();

    // Demonstrate collaborative task execution
    println!("🎯 Executing collaborative task:");
    println!("\"Create a comprehensive guide on sustainable gardening practices\"");
    println!();

    let result = forest
        .execute_collaborative_task(
            &"coordinator".to_string(),
            "Create a comprehensive guide on sustainable gardening practices. This should include \
            environmental benefits, practical techniques, common challenges, and tips for beginners. \
            Make it informative yet accessible to people new to sustainable gardening.".to_string(),
            vec![
                "researcher".to_string(),
                "writer".to_string(),
            ],
        )
        .await?;

    println!("📄 Final Result:");
    println!("{}", "=".repeat(60));
    println!("{}", result);
    println!("{}", "=".repeat(60));
    println!();

    // Demonstrate direct agent communication
    println!("💬 Demonstrating inter-agent communication:");
    println!();

    let mut forest_clone = forest; // Clone for mutable operations

    // Send a direct message
    println!("📤 Coordinator sends a message to Researcher...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            Some(&"researcher".to_string()),
            "Please research the latest sustainable gardening techniques for urban environments."
                .to_string(),
        )
        .await?;

    // Process messages
    forest_clone.process_messages().await?;

    // Check what the researcher received
    if let Some(researcher) = forest_clone.get_agent(&"researcher".to_string()) {
        let messages = researcher.chat_session().messages.clone();
        if let Some(last_msg) = messages.last() {
            println!("📥 Researcher received: {}", last_msg.content);
        }
    }

    // Send a broadcast message
    println!("\n📢 Coordinator broadcasts an update...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            None, // None = broadcast
            "Team update: We've successfully completed the sustainable gardening guide. Great collaboration everyone!".to_string(),
        )
        .await?;

    forest_clone.process_messages().await?;

    // Check what agents received
    for agent_id in ["coordinator", "researcher", "writer"] {
        if let Some(agent) = forest_clone.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") {
                    println!("📥 {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    // Demonstrate shared context
    println!("\n🧠 Demonstrating shared context:");
    forest_clone
        .set_shared_context(
            "project_status".to_string(),
            serde_json::json!({
                "name": "Sustainable Gardening Guide",
                "status": "completed",
                "contributors": ["coordinator", "researcher", "writer"],
                "completion_date": "2025-11-02"
            }),
        )
        .await;

    let context = forest_clone.get_shared_context().await;
    if let Some(status) = context.get("project_status") {
        println!("📊 Shared project status: {}", status);
    }

    println!("\n✅ Forest of Agents demo completed successfully!");
    println!("\nKey features demonstrated:");
    println!("  • Multi-agent collaboration on complex tasks");
    println!("  • Inter-agent communication (direct and broadcast)");
    println!("  • Task delegation and coordination");
    println!("  • Shared context and memory");
    println!("  • Specialized agent roles working together");

    Ok(())
}

pub fn config(self, config: Config) -> Self

Sets the configuration for all agents in the forest.

Examples found in repository

examples/send_message_tool_demo.rs (line 29)

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

    // Load configuration
    let config = Config::from_file("config.toml")?;
    println!("✓ Loaded configuration from config.toml");

    // Create a simple forest with two agents
    let mut forest = ForestBuilder::new()
        .config(config)
        .agent(
            "alice".to_string(),
            Agent::builder("alice")
                .system_prompt("You are Alice, a helpful communication assistant."),
        )
        .agent(
            "bob".to_string(),
            Agent::builder("bob")
                .system_prompt("You are Bob, a friendly colleague who responds to messages."),
        )
        .max_iterations(3)
        .build()
        .await?;

    println!("✓ Created Forest with 2 agents: Alice and Bob");
    println!();

    // Demonstrate SendMessageTool direct messaging
    println!("📤 Testing SendMessageTool - Direct Message:");
    println!("---------------------------------------------");

    // Create the tool for Alice
    let message_queue = Arc::new(RwLock::new(Vec::new()));
    let shared_context = Arc::new(RwLock::new(helios_engine::SharedContext::new()));

    let send_tool = SendMessageTool::new(
        "alice".to_string(),
        Arc::clone(&message_queue),
        Arc::clone(&shared_context),
    );

    // Test 1: Send a direct message from Alice to Bob
    println!("1. Alice sends a direct message to Bob...");

    let direct_message_args = serde_json::json!({
        "to": "bob",
        "message": "Hi Bob! How are you doing today?"
    });

    let result = send_tool.execute(direct_message_args).await?;
    println!("   Tool result: {}", result.output);
    println!("   Success: {}", result.success);

    // Check the message queue
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.first() {
            println!("   Message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    // Check shared context
    {
        let context = shared_context.read().await;
        let messages = context.get_recent_messages(10);
        println!("   Messages in shared context: {}", messages.len());
    }

    println!();

    // Test 2: Send a broadcast message
    println!("2. Alice broadcasts a message to everyone...");

    let broadcast_message_args = serde_json::json!({
        "message": "Hello everyone! This is a broadcast message from Alice."
    });

    let result2 = send_tool.execute(broadcast_message_args).await?;
    println!("   Tool result: {}", result2.output);
    println!("   Success: {}", result2.success);

    // Check the message queue after broadcast
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.last() {
            println!("   Latest message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    println!();

    // Demonstrate integration with Forest messaging system
    println!("🌲 Testing Forest Integration:");
    println!("------------------------------");

    // Clear our test queues and use the forest's messaging system
    {
        let mut queue = message_queue.write().await;
        queue.clear();
    }

    println!("3. Using Forest's messaging system...");

    // Send message through the forest
    forest
        .send_message(
            &"alice".to_string(),
            Some(&"bob".to_string()),
            "Hello Bob via Forest messaging!".to_string(),
        )
        .await?;

    // Process messages
    forest.process_messages().await?;

    // Check if Bob received the message
    if let Some(bob) = forest.get_agent(&"bob".to_string()) {
        let messages = bob.chat_session().messages.clone();
        println!("   Bob's message count: {}", messages.len());
        if let Some(last_msg) = messages.last() {
            println!("   Bob received: {}", last_msg.content);
        }
    }

    println!();

    // Test broadcast through forest
    println!("4. Forest broadcast message...");

    forest
        .send_message(
            &"alice".to_string(),
            None, // Broadcast
            "Forest broadcast: Meeting at 3 PM!".to_string(),
        )
        .await?;

    forest.process_messages().await?;

    // Check all agents received the broadcast
    for agent_id in ["alice", "bob"] {
        if let Some(agent) = forest.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") || last_msg.content.contains("Meeting") {
                    println!("   {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    println!();
    println!("✅ SendMessageTool demo completed successfully!");
    println!();
    println!("Key features tested:");
    println!("  • Direct messaging between agents");
    println!("  • Broadcast messaging to all agents");
    println!("  • Message queue management");
    println!("  • Shared context integration");
    println!("  • Forest messaging system integration");

    Ok(())
}

examples/forest_of_agents.rs (line 26)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Forest of Agents Demo");
    println!("=========================================\n");

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

    // Create a Forest of Agents with specialized agents
    let mut forest = ForestBuilder::new()
        .config(config)
        // Coordinator agent - manages the team and delegates tasks
        .agent(
            "coordinator".to_string(),
            Agent::builder("coordinator")
                .system_prompt(
                    "You are a project coordinator responsible for breaking down complex tasks \
                    and delegating them to specialized team members. You communicate with other \
                    agents to ensure the project is completed successfully. Use the available \
                    communication tools to delegate tasks, share information, and coordinate work."
                )
        )
        // Research agent - gathers and analyzes information
        .agent(
            "researcher".to_string(),
            Agent::builder("researcher")
                .system_prompt(
                    "You are a research specialist who excels at gathering information, \
                    analyzing data, and providing insights. You work closely with the coordinator \
                    and writer to ensure all work is based on accurate information. Use \
                    communication tools to share your findings and request clarification when needed."
                )
        )
        // Writer agent - creates content and documentation
        .agent(
            "writer".to_string(),
            Agent::builder("writer")
                .system_prompt(
                    "You are a skilled writer who creates clear, well-structured content and \
                    documentation. You work with the coordinator and researcher to produce \
                    high-quality written materials. Use communication tools to request information \
                    from the researcher and coordinate with the coordinator on project requirements."
                )
        )
        .max_iterations(5)
        .build()
        .await?;

    println!("✓ Created Forest of Agents with 3 specialized agents:");
    println!("  • Coordinator: Manages projects and delegates tasks");
    println!("  • Researcher: Gathers and analyzes information");
    println!("  • Writer: Creates content and documentation");
    println!();

    // Demonstrate collaborative task execution
    println!("🎯 Executing collaborative task:");
    println!("\"Create a comprehensive guide on sustainable gardening practices\"");
    println!();

    let result = forest
        .execute_collaborative_task(
            &"coordinator".to_string(),
            "Create a comprehensive guide on sustainable gardening practices. This should include \
            environmental benefits, practical techniques, common challenges, and tips for beginners. \
            Make it informative yet accessible to people new to sustainable gardening.".to_string(),
            vec![
                "researcher".to_string(),
                "writer".to_string(),
            ],
        )
        .await?;

    println!("📄 Final Result:");
    println!("{}", "=".repeat(60));
    println!("{}", result);
    println!("{}", "=".repeat(60));
    println!();

    // Demonstrate direct agent communication
    println!("💬 Demonstrating inter-agent communication:");
    println!();

    let mut forest_clone = forest; // Clone for mutable operations

    // Send a direct message
    println!("📤 Coordinator sends a message to Researcher...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            Some(&"researcher".to_string()),
            "Please research the latest sustainable gardening techniques for urban environments."
                .to_string(),
        )
        .await?;

    // Process messages
    forest_clone.process_messages().await?;

    // Check what the researcher received
    if let Some(researcher) = forest_clone.get_agent(&"researcher".to_string()) {
        let messages = researcher.chat_session().messages.clone();
        if let Some(last_msg) = messages.last() {
            println!("📥 Researcher received: {}", last_msg.content);
        }
    }

    // Send a broadcast message
    println!("\n📢 Coordinator broadcasts an update...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            None, // None = broadcast
            "Team update: We've successfully completed the sustainable gardening guide. Great collaboration everyone!".to_string(),
        )
        .await?;

    forest_clone.process_messages().await?;

    // Check what agents received
    for agent_id in ["coordinator", "researcher", "writer"] {
        if let Some(agent) = forest_clone.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") {
                    println!("📥 {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    // Demonstrate shared context
    println!("\n🧠 Demonstrating shared context:");
    forest_clone
        .set_shared_context(
            "project_status".to_string(),
            serde_json::json!({
                "name": "Sustainable Gardening Guide",
                "status": "completed",
                "contributors": ["coordinator", "researcher", "writer"],
                "completion_date": "2025-11-02"
            }),
        )
        .await;

    let context = forest_clone.get_shared_context().await;
    if let Some(status) = context.get("project_status") {
        println!("📊 Shared project status: {}", status);
    }

    println!("\n✅ Forest of Agents demo completed successfully!");
    println!("\nKey features demonstrated:");
    println!("  • Multi-agent collaboration on complex tasks");
    println!("  • Inter-agent communication (direct and broadcast)");
    println!("  • Task delegation and coordination");
    println!("  • Shared context and memory");
    println!("  • Specialized agent roles working together");

    Ok(())
}

pub fn agent(self, id: AgentId, builder: AgentBuilder) -> Self

Adds an agent to the forest with a builder.

Examples found in repository

examples/send_message_tool_demo.rs (lines 30-34)

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

    // Load configuration
    let config = Config::from_file("config.toml")?;
    println!("✓ Loaded configuration from config.toml");

    // Create a simple forest with two agents
    let mut forest = ForestBuilder::new()
        .config(config)
        .agent(
            "alice".to_string(),
            Agent::builder("alice")
                .system_prompt("You are Alice, a helpful communication assistant."),
        )
        .agent(
            "bob".to_string(),
            Agent::builder("bob")
                .system_prompt("You are Bob, a friendly colleague who responds to messages."),
        )
        .max_iterations(3)
        .build()
        .await?;

    println!("✓ Created Forest with 2 agents: Alice and Bob");
    println!();

    // Demonstrate SendMessageTool direct messaging
    println!("📤 Testing SendMessageTool - Direct Message:");
    println!("---------------------------------------------");

    // Create the tool for Alice
    let message_queue = Arc::new(RwLock::new(Vec::new()));
    let shared_context = Arc::new(RwLock::new(helios_engine::SharedContext::new()));

    let send_tool = SendMessageTool::new(
        "alice".to_string(),
        Arc::clone(&message_queue),
        Arc::clone(&shared_context),
    );

    // Test 1: Send a direct message from Alice to Bob
    println!("1. Alice sends a direct message to Bob...");

    let direct_message_args = serde_json::json!({
        "to": "bob",
        "message": "Hi Bob! How are you doing today?"
    });

    let result = send_tool.execute(direct_message_args).await?;
    println!("   Tool result: {}", result.output);
    println!("   Success: {}", result.success);

    // Check the message queue
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.first() {
            println!("   Message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    // Check shared context
    {
        let context = shared_context.read().await;
        let messages = context.get_recent_messages(10);
        println!("   Messages in shared context: {}", messages.len());
    }

    println!();

    // Test 2: Send a broadcast message
    println!("2. Alice broadcasts a message to everyone...");

    let broadcast_message_args = serde_json::json!({
        "message": "Hello everyone! This is a broadcast message from Alice."
    });

    let result2 = send_tool.execute(broadcast_message_args).await?;
    println!("   Tool result: {}", result2.output);
    println!("   Success: {}", result2.success);

    // Check the message queue after broadcast
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.last() {
            println!("   Latest message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    println!();

    // Demonstrate integration with Forest messaging system
    println!("🌲 Testing Forest Integration:");
    println!("------------------------------");

    // Clear our test queues and use the forest's messaging system
    {
        let mut queue = message_queue.write().await;
        queue.clear();
    }

    println!("3. Using Forest's messaging system...");

    // Send message through the forest
    forest
        .send_message(
            &"alice".to_string(),
            Some(&"bob".to_string()),
            "Hello Bob via Forest messaging!".to_string(),
        )
        .await?;

    // Process messages
    forest.process_messages().await?;

    // Check if Bob received the message
    if let Some(bob) = forest.get_agent(&"bob".to_string()) {
        let messages = bob.chat_session().messages.clone();
        println!("   Bob's message count: {}", messages.len());
        if let Some(last_msg) = messages.last() {
            println!("   Bob received: {}", last_msg.content);
        }
    }

    println!();

    // Test broadcast through forest
    println!("4. Forest broadcast message...");

    forest
        .send_message(
            &"alice".to_string(),
            None, // Broadcast
            "Forest broadcast: Meeting at 3 PM!".to_string(),
        )
        .await?;

    forest.process_messages().await?;

    // Check all agents received the broadcast
    for agent_id in ["alice", "bob"] {
        if let Some(agent) = forest.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") || last_msg.content.contains("Meeting") {
                    println!("   {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    println!();
    println!("✅ SendMessageTool demo completed successfully!");
    println!();
    println!("Key features tested:");
    println!("  • Direct messaging between agents");
    println!("  • Broadcast messaging to all agents");
    println!("  • Message queue management");
    println!("  • Shared context integration");
    println!("  • Forest messaging system integration");

    Ok(())
}

examples/forest_of_agents.rs (lines 28-37)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Forest of Agents Demo");
    println!("=========================================\n");

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

    // Create a Forest of Agents with specialized agents
    let mut forest = ForestBuilder::new()
        .config(config)
        // Coordinator agent - manages the team and delegates tasks
        .agent(
            "coordinator".to_string(),
            Agent::builder("coordinator")
                .system_prompt(
                    "You are a project coordinator responsible for breaking down complex tasks \
                    and delegating them to specialized team members. You communicate with other \
                    agents to ensure the project is completed successfully. Use the available \
                    communication tools to delegate tasks, share information, and coordinate work."
                )
        )
        // Research agent - gathers and analyzes information
        .agent(
            "researcher".to_string(),
            Agent::builder("researcher")
                .system_prompt(
                    "You are a research specialist who excels at gathering information, \
                    analyzing data, and providing insights. You work closely with the coordinator \
                    and writer to ensure all work is based on accurate information. Use \
                    communication tools to share your findings and request clarification when needed."
                )
        )
        // Writer agent - creates content and documentation
        .agent(
            "writer".to_string(),
            Agent::builder("writer")
                .system_prompt(
                    "You are a skilled writer who creates clear, well-structured content and \
                    documentation. You work with the coordinator and researcher to produce \
                    high-quality written materials. Use communication tools to request information \
                    from the researcher and coordinate with the coordinator on project requirements."
                )
        )
        .max_iterations(5)
        .build()
        .await?;

    println!("✓ Created Forest of Agents with 3 specialized agents:");
    println!("  • Coordinator: Manages projects and delegates tasks");
    println!("  • Researcher: Gathers and analyzes information");
    println!("  • Writer: Creates content and documentation");
    println!();

    // Demonstrate collaborative task execution
    println!("🎯 Executing collaborative task:");
    println!("\"Create a comprehensive guide on sustainable gardening practices\"");
    println!();

    let result = forest
        .execute_collaborative_task(
            &"coordinator".to_string(),
            "Create a comprehensive guide on sustainable gardening practices. This should include \
            environmental benefits, practical techniques, common challenges, and tips for beginners. \
            Make it informative yet accessible to people new to sustainable gardening.".to_string(),
            vec![
                "researcher".to_string(),
                "writer".to_string(),
            ],
        )
        .await?;

    println!("📄 Final Result:");
    println!("{}", "=".repeat(60));
    println!("{}", result);
    println!("{}", "=".repeat(60));
    println!();

    // Demonstrate direct agent communication
    println!("💬 Demonstrating inter-agent communication:");
    println!();

    let mut forest_clone = forest; // Clone for mutable operations

    // Send a direct message
    println!("📤 Coordinator sends a message to Researcher...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            Some(&"researcher".to_string()),
            "Please research the latest sustainable gardening techniques for urban environments."
                .to_string(),
        )
        .await?;

    // Process messages
    forest_clone.process_messages().await?;

    // Check what the researcher received
    if let Some(researcher) = forest_clone.get_agent(&"researcher".to_string()) {
        let messages = researcher.chat_session().messages.clone();
        if let Some(last_msg) = messages.last() {
            println!("📥 Researcher received: {}", last_msg.content);
        }
    }

    // Send a broadcast message
    println!("\n📢 Coordinator broadcasts an update...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            None, // None = broadcast
            "Team update: We've successfully completed the sustainable gardening guide. Great collaboration everyone!".to_string(),
        )
        .await?;

    forest_clone.process_messages().await?;

    // Check what agents received
    for agent_id in ["coordinator", "researcher", "writer"] {
        if let Some(agent) = forest_clone.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") {
                    println!("📥 {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    // Demonstrate shared context
    println!("\n🧠 Demonstrating shared context:");
    forest_clone
        .set_shared_context(
            "project_status".to_string(),
            serde_json::json!({
                "name": "Sustainable Gardening Guide",
                "status": "completed",
                "contributors": ["coordinator", "researcher", "writer"],
                "completion_date": "2025-11-02"
            }),
        )
        .await;

    let context = forest_clone.get_shared_context().await;
    if let Some(status) = context.get("project_status") {
        println!("📊 Shared project status: {}", status);
    }

    println!("\n✅ Forest of Agents demo completed successfully!");
    println!("\nKey features demonstrated:");
    println!("  • Multi-agent collaboration on complex tasks");
    println!("  • Inter-agent communication (direct and broadcast)");
    println!("  • Task delegation and coordination");
    println!("  • Shared context and memory");
    println!("  • Specialized agent roles working together");

    Ok(())
}

pub fn max_iterations(self, max: usize) -> Self

Sets the maximum iterations for agent interactions.

Examples found in repository

examples/send_message_tool_demo.rs (line 40)

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

    // Load configuration
    let config = Config::from_file("config.toml")?;
    println!("✓ Loaded configuration from config.toml");

    // Create a simple forest with two agents
    let mut forest = ForestBuilder::new()
        .config(config)
        .agent(
            "alice".to_string(),
            Agent::builder("alice")
                .system_prompt("You are Alice, a helpful communication assistant."),
        )
        .agent(
            "bob".to_string(),
            Agent::builder("bob")
                .system_prompt("You are Bob, a friendly colleague who responds to messages."),
        )
        .max_iterations(3)
        .build()
        .await?;

    println!("✓ Created Forest with 2 agents: Alice and Bob");
    println!();

    // Demonstrate SendMessageTool direct messaging
    println!("📤 Testing SendMessageTool - Direct Message:");
    println!("---------------------------------------------");

    // Create the tool for Alice
    let message_queue = Arc::new(RwLock::new(Vec::new()));
    let shared_context = Arc::new(RwLock::new(helios_engine::SharedContext::new()));

    let send_tool = SendMessageTool::new(
        "alice".to_string(),
        Arc::clone(&message_queue),
        Arc::clone(&shared_context),
    );

    // Test 1: Send a direct message from Alice to Bob
    println!("1. Alice sends a direct message to Bob...");

    let direct_message_args = serde_json::json!({
        "to": "bob",
        "message": "Hi Bob! How are you doing today?"
    });

    let result = send_tool.execute(direct_message_args).await?;
    println!("   Tool result: {}", result.output);
    println!("   Success: {}", result.success);

    // Check the message queue
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.first() {
            println!("   Message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    // Check shared context
    {
        let context = shared_context.read().await;
        let messages = context.get_recent_messages(10);
        println!("   Messages in shared context: {}", messages.len());
    }

    println!();

    // Test 2: Send a broadcast message
    println!("2. Alice broadcasts a message to everyone...");

    let broadcast_message_args = serde_json::json!({
        "message": "Hello everyone! This is a broadcast message from Alice."
    });

    let result2 = send_tool.execute(broadcast_message_args).await?;
    println!("   Tool result: {}", result2.output);
    println!("   Success: {}", result2.success);

    // Check the message queue after broadcast
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.last() {
            println!("   Latest message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    println!();

    // Demonstrate integration with Forest messaging system
    println!("🌲 Testing Forest Integration:");
    println!("------------------------------");

    // Clear our test queues and use the forest's messaging system
    {
        let mut queue = message_queue.write().await;
        queue.clear();
    }

    println!("3. Using Forest's messaging system...");

    // Send message through the forest
    forest
        .send_message(
            &"alice".to_string(),
            Some(&"bob".to_string()),
            "Hello Bob via Forest messaging!".to_string(),
        )
        .await?;

    // Process messages
    forest.process_messages().await?;

    // Check if Bob received the message
    if let Some(bob) = forest.get_agent(&"bob".to_string()) {
        let messages = bob.chat_session().messages.clone();
        println!("   Bob's message count: {}", messages.len());
        if let Some(last_msg) = messages.last() {
            println!("   Bob received: {}", last_msg.content);
        }
    }

    println!();

    // Test broadcast through forest
    println!("4. Forest broadcast message...");

    forest
        .send_message(
            &"alice".to_string(),
            None, // Broadcast
            "Forest broadcast: Meeting at 3 PM!".to_string(),
        )
        .await?;

    forest.process_messages().await?;

    // Check all agents received the broadcast
    for agent_id in ["alice", "bob"] {
        if let Some(agent) = forest.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") || last_msg.content.contains("Meeting") {
                    println!("   {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    println!();
    println!("✅ SendMessageTool demo completed successfully!");
    println!();
    println!("Key features tested:");
    println!("  • Direct messaging between agents");
    println!("  • Broadcast messaging to all agents");
    println!("  • Message queue management");
    println!("  • Shared context integration");
    println!("  • Forest messaging system integration");

    Ok(())
}

examples/forest_of_agents.rs (line 60)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Forest of Agents Demo");
    println!("=========================================\n");

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

    // Create a Forest of Agents with specialized agents
    let mut forest = ForestBuilder::new()
        .config(config)
        // Coordinator agent - manages the team and delegates tasks
        .agent(
            "coordinator".to_string(),
            Agent::builder("coordinator")
                .system_prompt(
                    "You are a project coordinator responsible for breaking down complex tasks \
                    and delegating them to specialized team members. You communicate with other \
                    agents to ensure the project is completed successfully. Use the available \
                    communication tools to delegate tasks, share information, and coordinate work."
                )
        )
        // Research agent - gathers and analyzes information
        .agent(
            "researcher".to_string(),
            Agent::builder("researcher")
                .system_prompt(
                    "You are a research specialist who excels at gathering information, \
                    analyzing data, and providing insights. You work closely with the coordinator \
                    and writer to ensure all work is based on accurate information. Use \
                    communication tools to share your findings and request clarification when needed."
                )
        )
        // Writer agent - creates content and documentation
        .agent(
            "writer".to_string(),
            Agent::builder("writer")
                .system_prompt(
                    "You are a skilled writer who creates clear, well-structured content and \
                    documentation. You work with the coordinator and researcher to produce \
                    high-quality written materials. Use communication tools to request information \
                    from the researcher and coordinate with the coordinator on project requirements."
                )
        )
        .max_iterations(5)
        .build()
        .await?;

    println!("✓ Created Forest of Agents with 3 specialized agents:");
    println!("  • Coordinator: Manages projects and delegates tasks");
    println!("  • Researcher: Gathers and analyzes information");
    println!("  • Writer: Creates content and documentation");
    println!();

    // Demonstrate collaborative task execution
    println!("🎯 Executing collaborative task:");
    println!("\"Create a comprehensive guide on sustainable gardening practices\"");
    println!();

    let result = forest
        .execute_collaborative_task(
            &"coordinator".to_string(),
            "Create a comprehensive guide on sustainable gardening practices. This should include \
            environmental benefits, practical techniques, common challenges, and tips for beginners. \
            Make it informative yet accessible to people new to sustainable gardening.".to_string(),
            vec![
                "researcher".to_string(),
                "writer".to_string(),
            ],
        )
        .await?;

    println!("📄 Final Result:");
    println!("{}", "=".repeat(60));
    println!("{}", result);
    println!("{}", "=".repeat(60));
    println!();

    // Demonstrate direct agent communication
    println!("💬 Demonstrating inter-agent communication:");
    println!();

    let mut forest_clone = forest; // Clone for mutable operations

    // Send a direct message
    println!("📤 Coordinator sends a message to Researcher...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            Some(&"researcher".to_string()),
            "Please research the latest sustainable gardening techniques for urban environments."
                .to_string(),
        )
        .await?;

    // Process messages
    forest_clone.process_messages().await?;

    // Check what the researcher received
    if let Some(researcher) = forest_clone.get_agent(&"researcher".to_string()) {
        let messages = researcher.chat_session().messages.clone();
        if let Some(last_msg) = messages.last() {
            println!("📥 Researcher received: {}", last_msg.content);
        }
    }

    // Send a broadcast message
    println!("\n📢 Coordinator broadcasts an update...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            None, // None = broadcast
            "Team update: We've successfully completed the sustainable gardening guide. Great collaboration everyone!".to_string(),
        )
        .await?;

    forest_clone.process_messages().await?;

    // Check what agents received
    for agent_id in ["coordinator", "researcher", "writer"] {
        if let Some(agent) = forest_clone.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") {
                    println!("📥 {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    // Demonstrate shared context
    println!("\n🧠 Demonstrating shared context:");
    forest_clone
        .set_shared_context(
            "project_status".to_string(),
            serde_json::json!({
                "name": "Sustainable Gardening Guide",
                "status": "completed",
                "contributors": ["coordinator", "researcher", "writer"],
                "completion_date": "2025-11-02"
            }),
        )
        .await;

    let context = forest_clone.get_shared_context().await;
    if let Some(status) = context.get("project_status") {
        println!("📊 Shared project status: {}", status);
    }

    println!("\n✅ Forest of Agents demo completed successfully!");
    println!("\nKey features demonstrated:");
    println!("  • Multi-agent collaboration on complex tasks");
    println!("  • Inter-agent communication (direct and broadcast)");
    println!("  • Task delegation and coordination");
    println!("  • Shared context and memory");
    println!("  • Specialized agent roles working together");

    Ok(())
}

pub async fn build(self) -> Result<ForestOfAgents>

Builds the Forest of Agents.

Examples found in repository

examples/send_message_tool_demo.rs (line 41)

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

    // Load configuration
    let config = Config::from_file("config.toml")?;
    println!("✓ Loaded configuration from config.toml");

    // Create a simple forest with two agents
    let mut forest = ForestBuilder::new()
        .config(config)
        .agent(
            "alice".to_string(),
            Agent::builder("alice")
                .system_prompt("You are Alice, a helpful communication assistant."),
        )
        .agent(
            "bob".to_string(),
            Agent::builder("bob")
                .system_prompt("You are Bob, a friendly colleague who responds to messages."),
        )
        .max_iterations(3)
        .build()
        .await?;

    println!("✓ Created Forest with 2 agents: Alice and Bob");
    println!();

    // Demonstrate SendMessageTool direct messaging
    println!("📤 Testing SendMessageTool - Direct Message:");
    println!("---------------------------------------------");

    // Create the tool for Alice
    let message_queue = Arc::new(RwLock::new(Vec::new()));
    let shared_context = Arc::new(RwLock::new(helios_engine::SharedContext::new()));

    let send_tool = SendMessageTool::new(
        "alice".to_string(),
        Arc::clone(&message_queue),
        Arc::clone(&shared_context),
    );

    // Test 1: Send a direct message from Alice to Bob
    println!("1. Alice sends a direct message to Bob...");

    let direct_message_args = serde_json::json!({
        "to": "bob",
        "message": "Hi Bob! How are you doing today?"
    });

    let result = send_tool.execute(direct_message_args).await?;
    println!("   Tool result: {}", result.output);
    println!("   Success: {}", result.success);

    // Check the message queue
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.first() {
            println!("   Message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    // Check shared context
    {
        let context = shared_context.read().await;
        let messages = context.get_recent_messages(10);
        println!("   Messages in shared context: {}", messages.len());
    }

    println!();

    // Test 2: Send a broadcast message
    println!("2. Alice broadcasts a message to everyone...");

    let broadcast_message_args = serde_json::json!({
        "message": "Hello everyone! This is a broadcast message from Alice."
    });

    let result2 = send_tool.execute(broadcast_message_args).await?;
    println!("   Tool result: {}", result2.output);
    println!("   Success: {}", result2.success);

    // Check the message queue after broadcast
    {
        let queue = message_queue.read().await;
        println!("   Messages in queue: {}", queue.len());
        if let Some(msg) = queue.last() {
            println!("   Latest message details:");
            println!("     From: {}", msg.from);
            println!("     To: {:?}", msg.to);
            println!("     Content: {}", msg.content);
        }
    }

    println!();

    // Demonstrate integration with Forest messaging system
    println!("🌲 Testing Forest Integration:");
    println!("------------------------------");

    // Clear our test queues and use the forest's messaging system
    {
        let mut queue = message_queue.write().await;
        queue.clear();
    }

    println!("3. Using Forest's messaging system...");

    // Send message through the forest
    forest
        .send_message(
            &"alice".to_string(),
            Some(&"bob".to_string()),
            "Hello Bob via Forest messaging!".to_string(),
        )
        .await?;

    // Process messages
    forest.process_messages().await?;

    // Check if Bob received the message
    if let Some(bob) = forest.get_agent(&"bob".to_string()) {
        let messages = bob.chat_session().messages.clone();
        println!("   Bob's message count: {}", messages.len());
        if let Some(last_msg) = messages.last() {
            println!("   Bob received: {}", last_msg.content);
        }
    }

    println!();

    // Test broadcast through forest
    println!("4. Forest broadcast message...");

    forest
        .send_message(
            &"alice".to_string(),
            None, // Broadcast
            "Forest broadcast: Meeting at 3 PM!".to_string(),
        )
        .await?;

    forest.process_messages().await?;

    // Check all agents received the broadcast
    for agent_id in ["alice", "bob"] {
        if let Some(agent) = forest.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") || last_msg.content.contains("Meeting") {
                    println!("   {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    println!();
    println!("✅ SendMessageTool demo completed successfully!");
    println!();
    println!("Key features tested:");
    println!("  • Direct messaging between agents");
    println!("  • Broadcast messaging to all agents");
    println!("  • Message queue management");
    println!("  • Shared context integration");
    println!("  • Forest messaging system integration");

    Ok(())
}

examples/forest_of_agents.rs (line 61)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Forest of Agents Demo");
    println!("=========================================\n");

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

    // Create a Forest of Agents with specialized agents
    let mut forest = ForestBuilder::new()
        .config(config)
        // Coordinator agent - manages the team and delegates tasks
        .agent(
            "coordinator".to_string(),
            Agent::builder("coordinator")
                .system_prompt(
                    "You are a project coordinator responsible for breaking down complex tasks \
                    and delegating them to specialized team members. You communicate with other \
                    agents to ensure the project is completed successfully. Use the available \
                    communication tools to delegate tasks, share information, and coordinate work."
                )
        )
        // Research agent - gathers and analyzes information
        .agent(
            "researcher".to_string(),
            Agent::builder("researcher")
                .system_prompt(
                    "You are a research specialist who excels at gathering information, \
                    analyzing data, and providing insights. You work closely with the coordinator \
                    and writer to ensure all work is based on accurate information. Use \
                    communication tools to share your findings and request clarification when needed."
                )
        )
        // Writer agent - creates content and documentation
        .agent(
            "writer".to_string(),
            Agent::builder("writer")
                .system_prompt(
                    "You are a skilled writer who creates clear, well-structured content and \
                    documentation. You work with the coordinator and researcher to produce \
                    high-quality written materials. Use communication tools to request information \
                    from the researcher and coordinate with the coordinator on project requirements."
                )
        )
        .max_iterations(5)
        .build()
        .await?;

    println!("✓ Created Forest of Agents with 3 specialized agents:");
    println!("  • Coordinator: Manages projects and delegates tasks");
    println!("  • Researcher: Gathers and analyzes information");
    println!("  • Writer: Creates content and documentation");
    println!();

    // Demonstrate collaborative task execution
    println!("🎯 Executing collaborative task:");
    println!("\"Create a comprehensive guide on sustainable gardening practices\"");
    println!();

    let result = forest
        .execute_collaborative_task(
            &"coordinator".to_string(),
            "Create a comprehensive guide on sustainable gardening practices. This should include \
            environmental benefits, practical techniques, common challenges, and tips for beginners. \
            Make it informative yet accessible to people new to sustainable gardening.".to_string(),
            vec![
                "researcher".to_string(),
                "writer".to_string(),
            ],
        )
        .await?;

    println!("📄 Final Result:");
    println!("{}", "=".repeat(60));
    println!("{}", result);
    println!("{}", "=".repeat(60));
    println!();

    // Demonstrate direct agent communication
    println!("💬 Demonstrating inter-agent communication:");
    println!();

    let mut forest_clone = forest; // Clone for mutable operations

    // Send a direct message
    println!("📤 Coordinator sends a message to Researcher...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            Some(&"researcher".to_string()),
            "Please research the latest sustainable gardening techniques for urban environments."
                .to_string(),
        )
        .await?;

    // Process messages
    forest_clone.process_messages().await?;

    // Check what the researcher received
    if let Some(researcher) = forest_clone.get_agent(&"researcher".to_string()) {
        let messages = researcher.chat_session().messages.clone();
        if let Some(last_msg) = messages.last() {
            println!("📥 Researcher received: {}", last_msg.content);
        }
    }

    // Send a broadcast message
    println!("\n📢 Coordinator broadcasts an update...");
    forest_clone
        .send_message(
            &"coordinator".to_string(),
            None, // None = broadcast
            "Team update: We've successfully completed the sustainable gardening guide. Great collaboration everyone!".to_string(),
        )
        .await?;

    forest_clone.process_messages().await?;

    // Check what agents received
    for agent_id in ["coordinator", "researcher", "writer"] {
        if let Some(agent) = forest_clone.get_agent(&agent_id.to_string()) {
            let messages = agent.chat_session().messages.clone();
            if let Some(last_msg) = messages.last() {
                if last_msg.content.contains("broadcast") {
                    println!("📥 {} received broadcast: {}", agent_id, last_msg.content);
                }
            }
        }
    }

    // Demonstrate shared context
    println!("\n🧠 Demonstrating shared context:");
    forest_clone
        .set_shared_context(
            "project_status".to_string(),
            serde_json::json!({
                "name": "Sustainable Gardening Guide",
                "status": "completed",
                "contributors": ["coordinator", "researcher", "writer"],
                "completion_date": "2025-11-02"
            }),
        )
        .await;

    let context = forest_clone.get_shared_context().await;
    if let Some(status) = context.get("project_status") {
        println!("📊 Shared project status: {}", status);
    }

    println!("\n✅ Forest of Agents demo completed successfully!");
    println!("\nKey features demonstrated:");
    println!("  • Multi-agent collaboration on complex tasks");
    println!("  • Inter-agent communication (direct and broadcast)");
    println!("  • Task delegation and coordination");
    println!("  • Shared context and memory");
    println!("  • Specialized agent roles working together");

    Ok(())
}

Trait Implementations

impl Default for ForestBuilder

fn default() -> Self

Returns the “default value” for a type.