04_advanced_agent/

04_advanced_agent.rs

//! Advanced Agent Example
//!
//! This example demonstrates advanced features including:
//! - Custom tools with complex logic
//! - Agent configuration
//! - Task prioritization
//! - Response handling with different output types
//!
//! Run with: cargo run --example 04_advanced_agent --manifest-path ceylon/Cargo.toml

use ceylon_next::agent::{Agent, AgentConfig};
use ceylon_next::tasks::{OutputData, TaskRequest};
use ceylon_next::tools::ToolTrait;
use serde_json::{Value, json};

// A tool that simulates fetching weather data
struct WeatherTool;

impl ToolTrait for WeatherTool {
    fn name(&self) -> String {
        "get_weather".to_string()
    }

    fn description(&self) -> String {
        "Fetches weather information for a given city. \
         Returns temperature, conditions, and humidity."
            .to_string()
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "The city name to get weather for"
                }
            },
            "required": ["city"]
        })
    }

    fn execute(&self, input: Value) -> Value {
        let city = input["city"].as_str().unwrap_or("Unknown");

        // Simulate weather data
        let (temp, conditions) = match city.to_lowercase().as_str() {
            "london" => (15, "Cloudy with occasional rain"),
            "paris" => (18, "Partly cloudy"),
            "tokyo" => (22, "Sunny"),
            "new york" => (12, "Clear skies"),
            _ => (20, "Mild conditions"),
        };

        json!({
            "city": city,
            "temperature_celsius": temp,
            "conditions": conditions,
            "humidity": 65,
            "wind_speed_kmh": 12
        })
    }
}

// A tool for text analysis
struct TextAnalyzerTool;

impl ToolTrait for TextAnalyzerTool {
    fn name(&self) -> String {
        "analyze_text".to_string()
    }

    fn description(&self) -> String {
        "Analyzes text and provides statistics like word count, character count, and readability."
            .to_string()
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "text": {
                    "type": "string",
                    "description": "The text to analyze"
                }
            },
            "required": ["text"]
        })
    }

    fn execute(&self, input: Value) -> Value {
        let text = input["text"].as_str().unwrap_or("");

        let words: Vec<&str> = text.split_whitespace().collect();
        let sentences = text.split('.').filter(|s| !s.trim().is_empty()).count();
        let avg_word_length = if !words.is_empty() {
            words.iter().map(|w| w.len()).sum::<usize>() / words.len()
        } else {
            0
        };

        json!({
            "text_length": text.len(),
            "word_count": words.len(),
            "sentence_count": sentences,
            "average_word_length": avg_word_length,
            "readability_score": 75.0 // Simplified score
        })
    }
}

#[tokio::main]
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!");
}