Struct AgentConfig 

pub struct AgentConfig { /* private fields */ }

Configuration for an AI Agent.

Controls various aspects of agent behavior including retry logic, timeouts, and goal analysis capabilities.

Examples

use ceylon_next::agent::AgentConfig;

// Create default configuration
let config = AgentConfig::default();

// Create custom configuration
let mut config = AgentConfig::new(5, 120);
config.with_goal_analysis(false);

Implementations

impl AgentConfig

pub fn new(max_retries: u64, timeout: u64) -> Self

Creates a new AgentConfig with specified retry and timeout settings.

Arguments

• max_retries - Maximum number of retries for failed operations
• timeout - Timeout in seconds for agent operations

Examples

use ceylon_next::agent::AgentConfig;

let config = AgentConfig::new(5, 120);

Examples found in repository

examples/01_basic_agent.rs (lines 20-23)

async fn main() {
    println!("🤖 Ceylon Agent - Basic Example\n");

    // Step 1: Create a new agent with a name and model
    // The model should be one supported by the LLM library (openai, anthropic, ollama, etc.)
    let mut agent = Agent::new("Assistant", "ollama::gemma3:latest");

    // Step 2: (Optional) Configure the agent with custom settings
    let config = AgentConfig::new(
        3,   // max_retries
        60,  // timeout in seconds
    );
    agent.with_config(config);

    // Step 3: (Optional) Customize the system prompt
    agent.with_system_prompt(
        "You are a helpful assistant that answers questions accurately and concisely. \
         Always provide well-structured responses."
    );

    // Step 4: Create a task request
    let mut task = TaskRequest::new("What is the capital of France?");
    task.with_name("Geography Question")
        .with_description("A simple geography question")
        .with_priority(5);

    // Step 5: Run the agent with the task
    println!("📋 Task: {}\n", "What is the capital of France?");
    let response = agent.run(task).await;

    // Step 6: Handle the response
    match response.result() {
        OutputData::Text(answer) => {
            println!("📝 Agent Response:\n{}\n", answer);
        }
        _ => {
            println!("❌ Unexpected response type");
        }
    }

    println!("✅ Example completed successfully!");
}

examples/04_advanced_agent.rs (lines 120-123)

async fn main() {
    println!("🤖 Ceylon Agent - Advanced Example\n");

    // Step 1: Create an agent with custom configuration
    let mut agent = Agent::new("AdvancedAssistant", "ollama::gemma3:latest");

    // Configure with custom settings
    let config = AgentConfig::new(
        5,   // Allow more retries for complex tasks
        120, // Longer timeout
    );
    agent.with_config(config);

    // Custom system prompt for the advanced agent
    agent.with_system_prompt(
        "You are an advanced AI assistant with access to specialized tools. \
         You can fetch weather data and analyze text. \
         Always explain your reasoning and use tools appropriately. \
         Provide detailed and accurate responses.",
    );

    // Step 2: Register multiple tools
    println!("🔧 Registering tools...");
    agent.add_tool(WeatherTool);
    agent.add_tool(TextAnalyzerTool);
    println!("✓ Tools registered: get_weather, analyze_text\n");

    // Step 3: Create and run multiple tasks with different priorities
    let tasks_data = vec![
        (
            "What's the weather in Paris and London? Compare them.",
            "Weather Comparison",
            "Compare weather in two cities",
            9, // High priority
        ),
        (
            "Analyze this text for readability: 'The quick brown fox jumps over the lazy dog. \
             This sentence demonstrates all letters of the English alphabet.'",
            "Text Analysis",
            "Analyze readability",
            5, // Medium priority
        ),
    ];

    for (prompt, name, description, priority) in tasks_data {
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!("📋 Task: {}", name);
        println!("⭐ Priority: {}/10", priority);
        println!("📝 Description: {}", description);
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let mut task = TaskRequest::new(prompt);
        task.with_name(name)
            .with_description(description)
            .with_priority(priority);

        // Run the agent
        println!("⏳ Running agent...\n");
        let response = agent.run(task).await;

        // Handle response
        match response.result() {
            OutputData::Text(answer) => {
                println!("✅ Task completed\n");
            }
            _ => {
                println!("⚠️ Unexpected response type\n");
            }
        }
    }

    // Step 4: Demonstrate memory capabilities
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📚 Agent Status Summary:");
    println!("• System Prompt: Custom advanced prompt");
    println!("• Tools Available: 2 (weather, text analyzer)");
    println!("• Memory Enabled: Yes");
    println!("• Max Retries: 5");
    println!("• Timeout: 120 seconds");
    println!("• Tasks Completed: 2\n");

    println!("✅ Advanced example completed successfully!");
}

pub fn with_goal_analysis(&mut self, enabled: bool) -> &mut Self

Enables or disables automatic goal analysis for tasks.

When enabled, the agent will automatically analyze incoming tasks and break them down into structured goals with sub-goals and success criteria.

Arguments

• enabled - Whether to enable goal analysis

Examples

use ceylon_next::agent::AgentConfig;

let mut config = AgentConfig::default();
config.with_goal_analysis(false);

Trait Implementations

impl Clone for AgentConfig

fn clone(&self) -> AgentConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for AgentConfig

fn default() -> Self

Returns the “default value” for a type.