Struct TaskRequest 

pub struct TaskRequest { /* private fields */ }

A request for an agent to perform a task.

TaskRequest encapsulates all the information needed for an agent to process a user request, including optional metadata like name, description, and priority.

Examples

use ceylon_next::tasks::TaskRequest;

// Simple task
let task = TaskRequest::new("What is 2 + 2?");

// Task with metadata
let mut task = TaskRequest::new("Analyze this data");
task.with_name("Data Analysis")
    .with_description("Perform statistical analysis on user data")
    .with_priority(8);

Implementations

impl TaskRequest

pub fn new(input_data: &str) -> Self

Creates a new task request with the given input.

Arguments

• input_data - The user’s request or question

Examples

use ceylon_next::tasks::TaskRequest;

let task = TaskRequest::new("Explain quantum computing");

Examples found in repository

examples/02_with_tools.rs (lines 156-158)

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

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

    agent.with_system_prompt(
        "You are a helpful math and text assistant. \
         Use the available tools to help the user. \
         Be clear about what tools you're using and why."
    );

    // Step 2: Register custom tools with the agent
    println!("🔧 Registering tools...");
    agent.add_tool(CalculatorTool);
    agent.add_tool(StringToolTool);
    println!("✓ Tools registered\n");

    // Step 3: Create a task that requires tool usage
    let mut task = TaskRequest::new(
        "Please calculate 25 + 15 + 10, and then tell me the uppercase version of the word 'hello'"
    );
    task.with_name("Complex Task")
        .with_description("A task requiring multiple tools")
        .with_priority(8);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    let response = agent.run(task).await;

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

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

examples/01_basic_agent.rs (line 33)

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/08_llm_providers.rs (line 131)

async fn basic_provider_usage() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using different providers with simple syntax:\n");

    // OpenAI
    println!("📘 OpenAI GPT-4:");
    let mut openai_agent = Agent::new("OpenAI Assistant", "openai::gpt-4");
    let task1 = TaskRequest::new("What is 2 + 2? Answer briefly.");
    let response = openai_agent.run(task1).await;
    println!("   Response: {:?}\n", response.result());

    // Anthropic Claude
    println!("📗 Anthropic Claude:");
    let mut anthropic_agent = Agent::new("Claude Assistant", "anthropic::claude-3-sonnet-20240229");
    let task2 = TaskRequest::new("What is 2 + 2? Answer briefly.");
    let response = anthropic_agent.run(task2).await;
    println!("   Response: {:?}\n", response.result());

    // Ollama (local)
    println!("📙 Ollama (Local):");
    let mut ollama_agent = Agent::new("Ollama Assistant", "ollama::llama3.2");
    let task3 = TaskRequest::new("What is 2 + 2? Answer briefly.");
    let response = ollama_agent.run(task3).await;
    println!("   Response: {:?}\n", response.result());

    // Google Gemini
    println!("📕 Google Gemini:");
    let mut gemini_agent = Agent::new("Gemini Assistant", "google::gemini-pro");
    let task4 = TaskRequest::new("What is 2 + 2? Answer briefly.");
    let response = gemini_agent.run(task4).await;
    println!("   Response: {:?}\n", response.result());

    // Groq
    println!("📔 Groq:");
    let mut groq_agent = Agent::new("Groq Assistant", "groq::mixtral-8x7b-32768");
    let task5 = TaskRequest::new("What is 2 + 2? Answer briefly.");
    let response = groq_agent.run(task5).await;
    println!("   Response: {:?}\n", response.result());

    Ok(())
}

/// Example 2: Advanced configuration with LLMConfig
async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

/// Example 3: Provider-specific features
async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

/// Example 4: Compare providers
async fn compare_providers() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Comparing responses across providers:\n");

    let providers = vec![
        ("OpenAI GPT-4", "openai::gpt-4", std::env::var("OPENAI_API_KEY").ok()),
        ("Anthropic Claude", "anthropic::claude-3-sonnet-20240229", std::env::var("ANTHROPIC_API_KEY").ok()),
        ("Ollama Llama", "ollama::llama3.2", None),
        ("Google Gemini", "google::gemini-pro", std::env::var("GOOGLE_API_KEY").ok()),
        ("Groq Mixtral", "groq::mixtral-8x7b-32768", std::env::var("GROQ_API_KEY").ok()),
    ];

    for (name, model, api_key) in providers {
        println!("🤖 {}:", name);

        let mut agent = Agent::new(name, model);

        // Configure with LLMConfig if API key is available
        if let Some(key) = api_key {
            let config = LLMConfig::new(model)
                .with_api_key(key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            if let Ok(_) = agent.with_llm_config(config) {
                let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
                let response = agent.run(task).await;
                println!("   ✓ {:?}", response.result());
            }
        } else {
            // Try without explicit API key (for Ollama or env vars)
            let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
            let response = agent.run(task).await;
            println!("   ✓ {:?}", response.result());
        }

        println!();
    }

    Ok(())
}

examples/05_with_goals.rs (line 58)

async fn example_1_manual_goal() {
    println!("=== Example 1: Manual Goal Creation ===\n");

    // Create an agent
    let mut agent = Agent::new("MealPlanner", "ollama::gemma3:latest");

    // Create a goal manually for a complex task
    let mut goal = Goal::new(
        "Plan a healthy meal prep for the week".to_string()
    );

    // Define what success looks like
    println!("📋 Setting success criteria...");
    goal.add_criterion("7 breakfast recipes selected".to_string());
    goal.add_criterion("7 lunch recipes selected".to_string());
    goal.add_criterion("7 dinner recipes selected".to_string());
    goal.add_criterion("Shopping list created".to_string());
    goal.add_criterion("Prep schedule created".to_string());

    // Break down into steps (sub-goals)
    println!("🎯 Breaking down into sub-goals...\n");
    goal.add_sub_goal("Ask user about dietary preferences".to_string(), 0);
    goal.add_sub_goal("Ask about time available for prep".to_string(), 1);
    goal.add_sub_goal("Suggest breakfast options".to_string(), 2);
    goal.add_sub_goal("Suggest lunch options".to_string(), 3);
    goal.add_sub_goal("Suggest dinner options".to_string(), 4);
    goal.add_sub_goal("Create shopping list".to_string(), 5);
    goal.add_sub_goal("Create prep schedule".to_string(), 6);

    // Start working on the goal
    goal.status = GoalStatus::InProgress;

    // Set the goal on the agent
    agent.set_goal(goal.clone());

    // Create a task aligned with the goal
    let task = TaskRequest::new("I need help with meal planning");

    // Run the agent
    println!("⏳ Agent is working on the meal planning task...\n");
    let _response = agent.run(task).await;

    // Show the goal summary
    println!("\n📊 Goal Summary:");
    println!("{}", goal.get_summary());

    println!("\n✅ Example 1 completed!\n");
}

// ============================================
// Example 2: Goal Progress Tracking
// ============================================

async fn example_2_goal_progress_tracking() {
    println!("\n=== Example 2: Goal Progress Tracking ===\n");

    // Create a goal for a project
    let mut goal = Goal::new(
        "Create a project plan for building a mobile app".to_string()
    );

    // Add success criteria
    goal.add_criterion("Project requirements documented".to_string());
    goal.add_criterion("Timeline created with milestones".to_string());
    goal.add_criterion("Resource allocation plan completed".to_string());
    goal.add_criterion("Risk assessment performed".to_string());

    // Add sub-goals
    goal.add_sub_goal("Gather stakeholder requirements".to_string(), 0);
    goal.add_sub_goal("Define project scope".to_string(), 1);
    goal.add_sub_goal("Create development timeline".to_string(), 2);
    goal.add_sub_goal("Allocate resources".to_string(), 3);
    goal.add_sub_goal("Identify risks and mitigation strategies".to_string(), 4);

    goal.status = GoalStatus::InProgress;

    // Simulate progress through the goal
    println!("📈 Tracking goal progress...\n");

    // Complete first sub-goal
    println!("Step 1: Gathering requirements");
    goal.complete_sub_goal(0, Some("Interviewed 5 stakeholders".to_string()));
    goal.mark_criterion_met(0, "Requirements documented".to_string());
    println!("  Progress: {}%\n", goal.get_progress());

    // Complete second sub-goal
    println!("Step 2: Defining scope");
    goal.complete_sub_goal(1, Some("Scope document created".to_string()));
    println!("  Progress: {}%\n", goal.get_progress());

    // Complete third sub-goal
    println!("Step 3: Creating timeline");
    goal.complete_sub_goal(2, Some("12-month timeline with milestones".to_string()));
    goal.mark_criterion_met(1, "Timeline created".to_string());
    println!("  Progress: {}%\n", goal.get_progress());

    // Complete fourth sub-goal
    println!("Step 4: Allocating resources");
    goal.complete_sub_goal(3, Some("Resource allocation table created".to_string()));
    goal.mark_criterion_met(2, "Resources allocated".to_string());
    println!("  Progress: {}%\n", goal.get_progress());

    // Complete fifth sub-goal
    println!("Step 5: Assessing risks");
    goal.complete_sub_goal(4, Some("Risk register created with 8 identified risks".to_string()));
    goal.mark_criterion_met(3, "Risks identified".to_string());
    println!("  Progress: {}%\n", goal.get_progress());

    // Show final status
    println!("\n📊 Final Goal Status:");
    println!("{}", goal.get_summary());

    println!("\n✅ Example 2 completed!\n");
}

// ============================================
// Example 3: Job Interview Preparation Goal
// ============================================

async fn example_3_interview_preparation() {
    println!("\n=== Example 3: Job Interview Preparation Goal ===\n");

    let mut agent = Agent::new("InterviewCoach", "ollama::gemma3:latest");

    // Create a structured goal for interview prep
    let mut goal = Goal::new(
        "Prepare for a senior software engineer interview at a tech company".to_string()
    );

    // Define success criteria
    println!("🎯 Success criteria:");
    goal.add_criterion("Technical topics reviewed (algorithms, data structures, system design)".to_string());
    goal.add_criterion("Behavioral questions prepared with STAR method examples".to_string());
    goal.add_criterion("Company research completed".to_string());
    goal.add_criterion("Practice mock interview conducted".to_string());
    goal.add_criterion("Questions to ask the interviewer prepared".to_string());

    for criterion in &goal.success_criteria {
        println!("  • {}", criterion.description);
    }

    // Define steps
    println!("\n📋 Steps to take:");
    goal.add_sub_goal("Review core algorithms and data structures".to_string(), 0);
    goal.add_sub_goal("Study system design patterns".to_string(), 1);
    goal.add_sub_goal("Prepare STAR method stories from past projects".to_string(), 2);
    goal.add_sub_goal("Research company background and culture".to_string(), 3);
    goal.add_sub_goal("Practice mock interview with a friend".to_string(), 4);
    goal.add_sub_goal("Prepare thoughtful questions about the role".to_string(), 5);

    for sub_goal in &goal.sub_goals {
        println!("  {}. {}", sub_goal.priority + 1, sub_goal.description);
    }

    goal.status = GoalStatus::InProgress;

    // Set goal on agent
    agent.set_goal(goal.clone());

    // Create related task
    let task = TaskRequest::new("Help me prepare for my senior engineer interview");

    println!("\n⏳ Agent is creating interview preparation plan...\n");
    let _response = agent.run(task).await;

    println!("\n📊 Goal Summary:");
    println!("{}", goal.get_summary());

    println!("\n✅ Example 3 completed!\n");
}

examples/06_nextjs_app_generator.rs (lines 70-74)

async fn example_1_basic_nextjs_app() {
    println!("=== Example 1: Generate a Basic Next.js App ===\n");

    // Create an agent that will generate the app
    let mut agent = Agent::new("NextJsGenerator", "ollama::gemma3:latest");

    // Create a goal for generating a Next.js app
    let mut goal = Goal::new(
        "Generate a Next.js web application with essential structure".to_string()
    );

    // Define success criteria
    goal.add_criterion("package.json created with dependencies".to_string());
    goal.add_criterion("next.config.js configuration file generated".to_string());
    goal.add_criterion("pages directory with index and api route created".to_string());
    goal.add_criterion("styles directory with global CSS".to_string());
    goal.add_criterion("README.md with setup instructions".to_string());

    // Define sub-goals (steps to generate the app)
    goal.add_sub_goal("Analyze Next.js requirements and best practices".to_string(), 0);
    goal.add_sub_goal("Generate package.json with required dependencies".to_string(), 1);
    goal.add_sub_goal("Create next.config.js configuration".to_string(), 2);
    goal.add_sub_goal("Generate pages (index.tsx, _app.tsx, _document.tsx)".to_string(), 3);
    goal.add_sub_goal("Create API route examples".to_string(), 4);
    goal.add_sub_goal("Generate styling setup (global.css, utilities)".to_string(), 5);
    goal.add_sub_goal("Create components directory with example components".to_string(), 6);
    goal.add_sub_goal("Generate README with setup and usage instructions".to_string(), 7);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    // Create a task to generate a Next.js app
    let task = TaskRequest::new(
        "Generate a modern Next.js 14 application with TypeScript, Tailwind CSS, and best practices. \
         Include package.json, next.config.js, sample pages, API routes, and components. \
         The app should be production-ready and follow Next.js conventions."
    );

    println!("📝 Task: Generate a Next.js application\n");
    println!("🎯 Success Criteria:");
    for criterion in &goal.success_criteria {
        println!("  • {}", criterion.description);
    }

    println!("\n⏳ Agent is generating the Next.js app...\n");
    let response = agent.run(task).await;

    // Extract and display the output
    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    // Show progress
    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("Status: {:?}", goal.status);

    println!("\n✅ Example 1 completed!\n");
}

// ============================================
// Example 2: E-Commerce Next.js App
// ============================================

async fn example_2_ecommerce_app() {
    println!("\n=== Example 2: Generate E-Commerce Next.js App ===\n");

    let mut agent = Agent::new("EcommerceGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a complete e-commerce Next.js application".to_string()
    );

    // Success criteria for e-commerce
    goal.add_criterion("Product listing page with filtering and sorting".to_string());
    goal.add_criterion("Product detail pages with dynamic routes".to_string());
    goal.add_criterion("Shopping cart functionality".to_string());
    goal.add_criterion("User authentication setup".to_string());
    goal.add_criterion("Payment integration structure".to_string());
    goal.add_criterion("Database models and API endpoints".to_string());
    goal.add_criterion("Admin dashboard layout".to_string());

    // Sub-goals
    goal.add_sub_goal("Design database schema for products and orders".to_string(), 0);
    goal.add_sub_goal("Create product API endpoints".to_string(), 1);
    goal.add_sub_goal("Build product listing and search components".to_string(), 2);
    goal.add_sub_goal("Implement product detail pages".to_string(), 3);
    goal.add_sub_goal("Create shopping cart context and management".to_string(), 4);
    goal.add_sub_goal("Build checkout flow pages".to_string(), 5);
    goal.add_sub_goal("Integrate payment gateway API".to_string(), 6);
    goal.add_sub_goal("Create admin dashboard pages".to_string(), 7);
    goal.add_sub_goal("Add authentication middleware".to_string(), 8);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a complete e-commerce Next.js application with: \
         1. Product management system (listing, search, filters)\n\
         2. Shopping cart with add/remove/update functionality\n\
         3. User authentication and profile pages\n\
         4. Payment integration endpoints\n\
         5. Order history and tracking\n\
         6. Admin dashboard for managing products and orders\n\
         7. Database models for PostgreSQL or MongoDB\n\
         8. RESTful API endpoints\n\
         Use TypeScript, Tailwind CSS, and modern React patterns."
    );

    println!("📝 Task: Generate E-Commerce Next.js Application\n");
    println!("🎯 Features to Generate:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating e-commerce app...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 2 completed!\n");
}

// ============================================
// Example 3: SaaS Dashboard App
// ============================================

async fn example_3_saas_dashboard() {
    println!("\n=== Example 3: Generate SaaS Dashboard Next.js App ===\n");

    let mut agent = Agent::new("SaasDashboardGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a SaaS dashboard application with user management".to_string()
    );

    goal.add_criterion("User authentication and authorization".to_string());
    goal.add_criterion("Multi-tenant database structure".to_string());
    goal.add_criterion("Dashboard with analytics and metrics".to_string());
    goal.add_criterion("User and team management pages".to_string());
    goal.add_criterion("Settings and preferences pages".to_string());
    goal.add_criterion("Billing and subscription management".to_string());
    goal.add_criterion("API for data collection and reporting".to_string());

    goal.add_sub_goal("Design multi-tenant database schema".to_string(), 0);
    goal.add_sub_goal("Implement OAuth authentication".to_string(), 1);
    goal.add_sub_goal("Create dashboard with charts and metrics".to_string(), 2);
    goal.add_sub_goal("Build team and user management interfaces".to_string(), 3);
    goal.add_sub_goal("Create settings pages for users and organization".to_string(), 4);
    goal.add_sub_goal("Implement billing API integration".to_string(), 5);
    goal.add_sub_goal("Create analytics and reporting system".to_string(), 6);
    goal.add_sub_goal("Add email notification templates".to_string(), 7);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a complete SaaS dashboard Next.js application with:\n\
         1. Multi-tenant authentication (OAuth + JWT)\n\
         2. Organization and team management\n\
         3. Comprehensive dashboard with charts and analytics\n\
         4. User permission and role management\n\
         5. Billing integration with Stripe\n\
         6. Settings pages for users and teams\n\
         7. Email notifications system\n\
         8. API logging and activity tracking\n\
         9. Dark mode support\n\
         10. Mobile responsive design\n\
         Include TypeScript, Tailwind CSS, Recharts for visualizations, \
         and PostgreSQL database models."
    );

    println!("📝 Task: Generate SaaS Dashboard Application\n");
    println!("🎯 Dashboard Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating SaaS dashboard...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 3 completed!\n");
}

// ============================================
// Example 4: Blog Platform with CMS
// ============================================

async fn example_4_blog_platform() {
    println!("\n=== Example 4: Generate Blog Platform with CMS ===\n");

    let mut agent = Agent::new("BlogCMSGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a comprehensive blog platform with CMS".to_string()
    );

    goal.add_criterion("Blog post management system".to_string());
    goal.add_criterion("Rich text editor with markdown support".to_string());
    goal.add_criterion("Category and tag system".to_string());
    goal.add_criterion("Search and filtering functionality".to_string());
    goal.add_criterion("Comments system with moderation".to_string());
    goal.add_criterion("SEO optimization (meta tags, sitemap)".to_string());
    goal.add_criterion("Author management and permissions".to_string());
    goal.add_criterion("Analytics and engagement tracking".to_string());

    goal.add_sub_goal("Design blog database schema".to_string(), 0);
    goal.add_sub_goal("Create CMS backend API".to_string(), 1);
    goal.add_sub_goal("Build post editor with markdown".to_string(), 2);
    goal.add_sub_goal("Create blog listing and search pages".to_string(), 3);
    goal.add_sub_goal("Build individual post pages with SEO".to_string(), 4);
    goal.add_sub_goal("Implement comments system".to_string(), 5);
    goal.add_sub_goal("Create author profiles and bio".to_string(), 6);
    goal.add_sub_goal("Build admin dashboard for content management".to_string(), 7);
    goal.add_sub_goal("Add analytics tracking and reporting".to_string(), 8);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a full-featured blog platform with CMS:\n\
         1. Post creation and editing with rich text editor\n\
         2. Markdown support with preview\n\
         3. Category and tag system\n\
         4. Advanced search with filters\n\
         5. Comments system with nested replies\n\
         6. Author profiles with biography\n\
         7. SEO optimization (sitemaps, meta tags, structured data)\n\
         8. Social sharing integration\n\
         9. Email newsletter subscription\n\
         10. Analytics dashboard for authors\n\
         11. Reading time estimates\n\
         12. Related posts suggestions\n\
         Include TypeScript, Tailwind CSS, next-mdx-remote for markdown, \
         and MongoDB/PostgreSQL models."
    );

    println!("📝 Task: Generate Blog Platform with CMS\n");
    println!("🎯 Blog Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating blog platform...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 4 completed!\n");
}

// ============================================
// Example 5: Extracting and Processing Output
// ============================================

async fn example_5_output_extraction() {
    println!("\n=== Example 5: Output Extraction and Processing ===\n");

    let mut agent = Agent::new("OutputProcessor", "ollama::gemma3:latest");

    // Create a simple task to generate specific file outputs
    let task = TaskRequest::new(
        "Generate ONLY the following files in proper format:\n\
         1. A complete package.json file for a Next.js project\n\
         2. A next.config.js configuration\n\
         3. A TypeScript types file for common types\n\
         Format each file with proper headers like:\n\
         === FILE: package.json ===\n\
         [file content]\n\
         === FILE: next.config.js ===\n\
         [file content]"
    );

    println!("📝 Task: Generate Specific Configuration Files\n");
    println!("⏳ Processing...\n");

    let response = agent.run(task).await;
    let output = extract_output_text(&response.result());

    // Parse output by file
    let files: HashMap<String, String> = parse_output_by_file(&output);

    println!("📦 Generated Files:\n");
    for (filename, content) in &files {
        println!("📄 File: {}", filename);
        println!("   Lines: {}", content.lines().count());
        println!("   Size: {} bytes\n", content.len());
    }

    println!("✅ Example 5 completed!\n");
}

examples/04_advanced_agent.rs (line 164)

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!");
}

Additional examples can be found in:

• examples/09_test_groq.rs
• examples/07_python_project_generator.rs
• examples/03_with_memory.rs
• examples/10_file_saving.rs
• examples/11_persistent_memory.rs

pub fn with_name(&mut self, name: &str) -> &mut Self

Sets the name of the task.

Arguments

• name - A short name for the task

Examples found in repository

examples/02_with_tools.rs (line 159)

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

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

    agent.with_system_prompt(
        "You are a helpful math and text assistant. \
         Use the available tools to help the user. \
         Be clear about what tools you're using and why."
    );

    // Step 2: Register custom tools with the agent
    println!("🔧 Registering tools...");
    agent.add_tool(CalculatorTool);
    agent.add_tool(StringToolTool);
    println!("✓ Tools registered\n");

    // Step 3: Create a task that requires tool usage
    let mut task = TaskRequest::new(
        "Please calculate 25 + 15 + 10, and then tell me the uppercase version of the word 'hello'"
    );
    task.with_name("Complex Task")
        .with_description("A task requiring multiple tools")
        .with_priority(8);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    let response = agent.run(task).await;

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

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

examples/01_basic_agent.rs (line 34)

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 (line 165)

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!");
}

examples/03_with_memory.rs (line 38)

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

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

    agent.with_system_prompt(
        "You are a helpful assistant with persistent memory. \
         Remember important details from our previous conversations \
         and refer back to them when relevant."
    );

    // Step 2: Run multiple tasks to build conversation history
    let tasks_and_prompts = vec![
        ("Tell me about your favorite color", "Learn about preferences"),
        ("What color did I mention?", "Test memory recall"),
        ("Can you suggest a hobby based on what you know about me?", "Use memory for suggestions"),
    ];

    for (prompt, description) in tasks_and_prompts {
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!("📋 Task: {}", prompt);
        println!("📝 Description: {}", description);
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let mut task = TaskRequest::new(prompt);
        task.with_name(description)
            .with_priority(5);

        // Run the agent
        let response = agent.run(task).await;

        // Display response
        match response.result() {
            OutputData::Text(answer) => {
                println!("✓ Response received\n");
            }
            _ => {
                println!("❌ Unexpected response type\n");
            }
        }
    }

    // Step 3: Retrieve conversation history
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📚 Retrieving conversation history...\n");

    let history = agent.get_history(Some(5)).await;
    println!("Found {} recent conversations\n", history.len());

    if !history.is_empty() {
        println!("📖 Conversation Summary:");
        for (i, entry) in history.iter().enumerate() {
            println!("\n--- Conversation {} ---", i + 1);
            println!("Messages: {}", entry.messages.len());

            // Show first and last message
            if let Some(first) = entry.messages.first() {
                println!("First: {} - {}", first.role,
                    if first.content.len() > 50 {
                        format!("{}...", &first.content[..50])
                    } else {
                        first.content.clone()
                    });
            }

            if let Some(last) = entry.messages.last() {
                println!("Last: {} - {}", last.role,
                    if last.content.len() > 50 {
                        format!("{}...", &last.content[..50])
                    } else {
                        last.content.clone()
                    });
            }
        }
    }

    // Step 4: Search memory
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🔍 Searching memory for 'color'...\n");

    let search_results = agent.search_memory("color").await;
    println!("Found {} conversations mentioning 'color'\n", search_results.len());

    // Step 5: Clear memory (optional)
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🧹 Memory management options:");
    println!("- Use agent.get_history() to retrieve conversation history");
    println!("- Use agent.search_memory(query) to search conversations");
    println!("- Use agent.clear_memory() to clear all agent memory\n");

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

examples/10_file_saving.rs (line 130)

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

    // Define the output directory
    let output_dir = "test/web_project_output";

    // Create the output directory if it doesn't exist
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("❌ Failed to create output directory: {}", e);
        return;
    }
    println!("📁 Output directory: {}/\n", output_dir);

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

    agent.with_system_prompt(
        &format!(
            "You are a helpful assistant that can generate content and save it to files. \
             When asked to create content, generate it and use the file_saver tool to save it. \
             \
             IMPORTANT: All files MUST be saved inside the '{}' directory. \
             For example, to save 'server.js', use '{}/server.js' as the filename. \
             For files in subdirectories, use '{}/src/app.js' format. \
             \
             Be clear about what you're creating and where you're saving it.",
            output_dir, output_dir, output_dir
        )
    );

    // Step 2: Register the file saver tool
    println!("🔧 Registering file saver tool...");
    agent.add_tool(FileSaverTool);
    println!("✓ Tool registered\n");

    // Step 3: Create a task that generates content and saves it
    let mut task = TaskRequest::new(
        &format!(
            "Create a simple web project with a file upload API. Save all files in the '{}' directory:\
             \n1. server.js - A Node.js Express server with POST /upload endpoint\
             \n2. package.json - Package configuration with dependencies\
             \n3. test.http - HTTP test file to test the upload endpoint\
             \n4. README.md - Instructions on how to install and run the server\
             \n\nMake sure ALL files are saved in the '{}' directory!",
            output_dir, output_dir
        )
    );
    task.with_name("Generate and Save Web Project")
        .with_description("Generate a complete web project with file upload API")
        .with_priority(7);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    println!("🔄 Running agent...\n");

    let response = agent.run(task).await;

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

    // Step 6: Verify files were created
    println!("🔍 Checking created files in '{}/'\n", output_dir);

    let expected_files = vec![
        "server.js",
        "package.json",
        "test.http",
        "README.md"
    ];

    let mut created_count = 0;

    for file in &expected_files {
        let file_path = format!("{}/{}", output_dir, file);
        if Path::new(&file_path).exists() {
            created_count += 1;
            println!("✓ {} created successfully", file);

            if let Ok(content) = fs::read_to_string(&file_path) {
                let preview: String = content.chars().take(100).collect();
                println!("  Preview: {}", preview.replace('\n', " "));
            }
        } else {
            println!("⚠ {} not found", file);
        }
    }

    println!("\n📊 Summary: {}/{} expected files created", created_count, expected_files.len());

    // Show directory structure
    println!("\n📂 Directory structure:");
    if let Ok(entries) = fs::read_dir(output_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() {
                if let Some(filename) = path.file_name() {
                    if let Ok(metadata) = entry.metadata() {
                        println!("  - {} ({} bytes)",
                                 filename.to_string_lossy(),
                                 metadata.len());
                    }
                }
            }
        }
    }

    println!("\n✅ Example completed successfully!");
    println!("📁 All files are in: {}/", output_dir);
}

pub fn with_description(&mut self, description: &str) -> &mut Self

Sets the description of the task.

Arguments

• description - A detailed description of what the task should accomplish

Examples found in repository

examples/02_with_tools.rs (line 160)

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

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

    agent.with_system_prompt(
        "You are a helpful math and text assistant. \
         Use the available tools to help the user. \
         Be clear about what tools you're using and why."
    );

    // Step 2: Register custom tools with the agent
    println!("🔧 Registering tools...");
    agent.add_tool(CalculatorTool);
    agent.add_tool(StringToolTool);
    println!("✓ Tools registered\n");

    // Step 3: Create a task that requires tool usage
    let mut task = TaskRequest::new(
        "Please calculate 25 + 15 + 10, and then tell me the uppercase version of the word 'hello'"
    );
    task.with_name("Complex Task")
        .with_description("A task requiring multiple tools")
        .with_priority(8);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    let response = agent.run(task).await;

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

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

examples/01_basic_agent.rs (line 35)

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 (line 166)

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!");
}

examples/10_file_saving.rs (line 131)

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

    // Define the output directory
    let output_dir = "test/web_project_output";

    // Create the output directory if it doesn't exist
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("❌ Failed to create output directory: {}", e);
        return;
    }
    println!("📁 Output directory: {}/\n", output_dir);

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

    agent.with_system_prompt(
        &format!(
            "You are a helpful assistant that can generate content and save it to files. \
             When asked to create content, generate it and use the file_saver tool to save it. \
             \
             IMPORTANT: All files MUST be saved inside the '{}' directory. \
             For example, to save 'server.js', use '{}/server.js' as the filename. \
             For files in subdirectories, use '{}/src/app.js' format. \
             \
             Be clear about what you're creating and where you're saving it.",
            output_dir, output_dir, output_dir
        )
    );

    // Step 2: Register the file saver tool
    println!("🔧 Registering file saver tool...");
    agent.add_tool(FileSaverTool);
    println!("✓ Tool registered\n");

    // Step 3: Create a task that generates content and saves it
    let mut task = TaskRequest::new(
        &format!(
            "Create a simple web project with a file upload API. Save all files in the '{}' directory:\
             \n1. server.js - A Node.js Express server with POST /upload endpoint\
             \n2. package.json - Package configuration with dependencies\
             \n3. test.http - HTTP test file to test the upload endpoint\
             \n4. README.md - Instructions on how to install and run the server\
             \n\nMake sure ALL files are saved in the '{}' directory!",
            output_dir, output_dir
        )
    );
    task.with_name("Generate and Save Web Project")
        .with_description("Generate a complete web project with file upload API")
        .with_priority(7);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    println!("🔄 Running agent...\n");

    let response = agent.run(task).await;

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

    // Step 6: Verify files were created
    println!("🔍 Checking created files in '{}/'\n", output_dir);

    let expected_files = vec![
        "server.js",
        "package.json",
        "test.http",
        "README.md"
    ];

    let mut created_count = 0;

    for file in &expected_files {
        let file_path = format!("{}/{}", output_dir, file);
        if Path::new(&file_path).exists() {
            created_count += 1;
            println!("✓ {} created successfully", file);

            if let Ok(content) = fs::read_to_string(&file_path) {
                let preview: String = content.chars().take(100).collect();
                println!("  Preview: {}", preview.replace('\n', " "));
            }
        } else {
            println!("⚠ {} not found", file);
        }
    }

    println!("\n📊 Summary: {}/{} expected files created", created_count, expected_files.len());

    // Show directory structure
    println!("\n📂 Directory structure:");
    if let Ok(entries) = fs::read_dir(output_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() {
                if let Some(filename) = path.file_name() {
                    if let Ok(metadata) = entry.metadata() {
                        println!("  - {} ({} bytes)",
                                 filename.to_string_lossy(),
                                 metadata.len());
                    }
                }
            }
        }
    }

    println!("\n✅ Example completed successfully!");
    println!("📁 All files are in: {}/", output_dir);
}

pub fn with_priority(&mut self, priority: u64) -> &mut Self

Sets the priority of the task (1-10, where 10 is highest).

Arguments

• priority - Task priority level

Examples found in repository

examples/02_with_tools.rs (line 161)

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

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

    agent.with_system_prompt(
        "You are a helpful math and text assistant. \
         Use the available tools to help the user. \
         Be clear about what tools you're using and why."
    );

    // Step 2: Register custom tools with the agent
    println!("🔧 Registering tools...");
    agent.add_tool(CalculatorTool);
    agent.add_tool(StringToolTool);
    println!("✓ Tools registered\n");

    // Step 3: Create a task that requires tool usage
    let mut task = TaskRequest::new(
        "Please calculate 25 + 15 + 10, and then tell me the uppercase version of the word 'hello'"
    );
    task.with_name("Complex Task")
        .with_description("A task requiring multiple tools")
        .with_priority(8);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    let response = agent.run(task).await;

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

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

examples/01_basic_agent.rs (line 36)

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 (line 167)

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!");
}

examples/03_with_memory.rs (line 39)

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

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

    agent.with_system_prompt(
        "You are a helpful assistant with persistent memory. \
         Remember important details from our previous conversations \
         and refer back to them when relevant."
    );

    // Step 2: Run multiple tasks to build conversation history
    let tasks_and_prompts = vec![
        ("Tell me about your favorite color", "Learn about preferences"),
        ("What color did I mention?", "Test memory recall"),
        ("Can you suggest a hobby based on what you know about me?", "Use memory for suggestions"),
    ];

    for (prompt, description) in tasks_and_prompts {
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!("📋 Task: {}", prompt);
        println!("📝 Description: {}", description);
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let mut task = TaskRequest::new(prompt);
        task.with_name(description)
            .with_priority(5);

        // Run the agent
        let response = agent.run(task).await;

        // Display response
        match response.result() {
            OutputData::Text(answer) => {
                println!("✓ Response received\n");
            }
            _ => {
                println!("❌ Unexpected response type\n");
            }
        }
    }

    // Step 3: Retrieve conversation history
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📚 Retrieving conversation history...\n");

    let history = agent.get_history(Some(5)).await;
    println!("Found {} recent conversations\n", history.len());

    if !history.is_empty() {
        println!("📖 Conversation Summary:");
        for (i, entry) in history.iter().enumerate() {
            println!("\n--- Conversation {} ---", i + 1);
            println!("Messages: {}", entry.messages.len());

            // Show first and last message
            if let Some(first) = entry.messages.first() {
                println!("First: {} - {}", first.role,
                    if first.content.len() > 50 {
                        format!("{}...", &first.content[..50])
                    } else {
                        first.content.clone()
                    });
            }

            if let Some(last) = entry.messages.last() {
                println!("Last: {} - {}", last.role,
                    if last.content.len() > 50 {
                        format!("{}...", &last.content[..50])
                    } else {
                        last.content.clone()
                    });
            }
        }
    }

    // Step 4: Search memory
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🔍 Searching memory for 'color'...\n");

    let search_results = agent.search_memory("color").await;
    println!("Found {} conversations mentioning 'color'\n", search_results.len());

    // Step 5: Clear memory (optional)
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🧹 Memory management options:");
    println!("- Use agent.get_history() to retrieve conversation history");
    println!("- Use agent.search_memory(query) to search conversations");
    println!("- Use agent.clear_memory() to clear all agent memory\n");

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

examples/10_file_saving.rs (line 132)

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

    // Define the output directory
    let output_dir = "test/web_project_output";

    // Create the output directory if it doesn't exist
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("❌ Failed to create output directory: {}", e);
        return;
    }
    println!("📁 Output directory: {}/\n", output_dir);

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

    agent.with_system_prompt(
        &format!(
            "You are a helpful assistant that can generate content and save it to files. \
             When asked to create content, generate it and use the file_saver tool to save it. \
             \
             IMPORTANT: All files MUST be saved inside the '{}' directory. \
             For example, to save 'server.js', use '{}/server.js' as the filename. \
             For files in subdirectories, use '{}/src/app.js' format. \
             \
             Be clear about what you're creating and where you're saving it.",
            output_dir, output_dir, output_dir
        )
    );

    // Step 2: Register the file saver tool
    println!("🔧 Registering file saver tool...");
    agent.add_tool(FileSaverTool);
    println!("✓ Tool registered\n");

    // Step 3: Create a task that generates content and saves it
    let mut task = TaskRequest::new(
        &format!(
            "Create a simple web project with a file upload API. Save all files in the '{}' directory:\
             \n1. server.js - A Node.js Express server with POST /upload endpoint\
             \n2. package.json - Package configuration with dependencies\
             \n3. test.http - HTTP test file to test the upload endpoint\
             \n4. README.md - Instructions on how to install and run the server\
             \n\nMake sure ALL files are saved in the '{}' directory!",
            output_dir, output_dir
        )
    );
    task.with_name("Generate and Save Web Project")
        .with_description("Generate a complete web project with file upload API")
        .with_priority(7);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    println!("🔄 Running agent...\n");

    let response = agent.run(task).await;

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

    // Step 6: Verify files were created
    println!("🔍 Checking created files in '{}/'\n", output_dir);

    let expected_files = vec![
        "server.js",
        "package.json",
        "test.http",
        "README.md"
    ];

    let mut created_count = 0;

    for file in &expected_files {
        let file_path = format!("{}/{}", output_dir, file);
        if Path::new(&file_path).exists() {
            created_count += 1;
            println!("✓ {} created successfully", file);

            if let Ok(content) = fs::read_to_string(&file_path) {
                let preview: String = content.chars().take(100).collect();
                println!("  Preview: {}", preview.replace('\n', " "));
            }
        } else {
            println!("⚠ {} not found", file);
        }
    }

    println!("\n📊 Summary: {}/{} expected files created", created_count, expected_files.len());

    // Show directory structure
    println!("\n📂 Directory structure:");
    if let Ok(entries) = fs::read_dir(output_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() {
                if let Some(filename) = path.file_name() {
                    if let Ok(metadata) = entry.metadata() {
                        println!("  - {} ({} bytes)",
                                 filename.to_string_lossy(),
                                 metadata.len());
                    }
                }
            }
        }
    }

    println!("\n✅ Example completed successfully!");
    println!("📁 All files are in: {}/", output_dir);
}

examples/11_persistent_memory.rs (line 45)

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

    // ============================================
    // Part 1: SQLite Backend
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📦 Part 1: SQLite Backend");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let sqlite_path = "agent_memory.db";
    let sqlite_store = SqliteStore::new(sqlite_path).await
        .expect("Failed to create SQLite store");

    let mut agent = Agent::new("PersistentAssistant", "ollama::gemma3:latest");
    agent.with_memory(Arc::new(sqlite_store))
         .with_system_prompt("You are a helpful assistant with persistent memory across sessions.");

    println!("✅ Created agent with SQLite backend at {}\n", sqlite_path);

    // Run some tasks to populate memory
    let tasks = vec![
        "My name is Alice and I love programming in Rust",
        "What programming language do I like?",
    ];

    for prompt in tasks {
        println!("📋 Task: {}", prompt);
        let mut task = TaskRequest::new(prompt);
        task.with_priority(5);

        let response = agent.run(task).await;
        if let OutputData::Text(_) = response.result() {
            println!("✓ Task completed\n");
        }
    }

    println!("📊 SQLite database now contains conversation history");
    println!("   This data persists even after the program exits!\n");

    // ============================================
    // Part 2: File-based Backend (JSON)
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📄 Part 2: File-based Backend (JSON)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let json_path = "agent_memory.json";
    let file_store = FileStore::new(json_path, StorageFormat::Json).await
        .expect("Failed to create File store");

    let mut agent2 = Agent::new("FileAssistant", "ollama::gemma3:latest");
    agent2.with_memory(Arc::new(file_store))
          .with_system_prompt("You are a helpful assistant storing memories in JSON files.");

    println!("✅ Created agent with JSON file backend at {}\n", json_path);

    let task = TaskRequest::new("Remember: My favorite color is blue");
    let response = agent2.run(task).await;

    if let OutputData::Text(_) = response.result() {
        println!("✓ Memory saved to JSON file");
        println!("   You can open {} to view the human-readable data!\n", json_path);
    }

    // ============================================
    // Part 3: MessagePack Backend
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📦 Part 3: MessagePack Backend (Compact Binary)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let msgpack_path = "agent_memory.msgpack";
    let msgpack_store = FileStore::new(msgpack_path, StorageFormat::MessagePack).await
        .expect("Failed to create MessagePack store");

    let mut agent3 = Agent::new("BinaryAssistant", "ollama::gemma3:latest");
    agent3.with_memory(Arc::new(msgpack_store))
          .with_system_prompt("You are a helpful assistant using compact binary storage.");

    println!("✅ Created agent with MessagePack backend at {}\n", msgpack_path);

    let task = TaskRequest::new("Store this efficiently: The quick brown fox jumps over the lazy dog");
    let response = agent3.run(task).await;

    if let OutputData::Text(_) = response.result() {
        println!("✓ Memory saved to MessagePack file");
        println!("   Binary format is more compact than JSON!\n");
    }

    // ============================================
    // Part 4: Memory Migration
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🔄 Part 4: Memory Migration Between Backends");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Create source and destination stores
    let source_db = SqliteStore::new("source.db").await.unwrap();

    // Create an agent with source backend and add some data
    let mut temp_agent = Agent::new("MigrationAgent", "ollama::gemma3:latest");
    temp_agent.with_memory(Arc::new(source_db));

    let task = TaskRequest::new("Migration test: This data will be migrated!");
    temp_agent.run(task).await;

    // Note: You would normally track your agent IDs. For this demo, we'll use
    // a known pattern - the agent creates entries with its own ID
    println!("💡 Tip: To migrate data, you need to know the agent's ID");
    println!("   In production, track agent IDs when creating agents\n");

    println!("✓ Migration between backends is available via migrate_memory()\n");
    println!("   Example: migrate_memory(&source, &target, \"agent-id\").await\n");

    // ============================================
    // Part 5: Export/Import Utilities
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("💾 Part 5: Export/Import Utilities");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Demonstrate export/import with the existing SQLite database
    println!("💡 Export and import utilities are available:\n");
    println!("   • export_to_json(store, agent_id, path)");
    println!("   • export_to_msgpack(store, agent_id, path)");
    println!("   • import_from_json(store, path)");
    println!("   • import_from_msgpack(store, path)\n");

    println!("✓ These functions allow you to backup and restore agent memories\n");

    // ============================================
    // Summary
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📊 Summary: Available Backends");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    println!("1. InMemoryStore (default)");
    println!("   • Fast, but data lost on restart");
    println!("   • Best for: Development, testing\n");

    println!("2. SqliteStore");
    println!("   • Persistent, efficient queries");
    println!("   • Best for: Production apps, large datasets\n");

    println!("3. FileStore (JSON)");
    println!("   • Human-readable, easy to inspect");
    println!("   • Best for: Debugging, data sharing\n");

    println!("4. FileStore (MessagePack)");
    println!("   • Compact binary format");
    println!("   • Best for: Large datasets, bandwidth constraints\n");

    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📝 Files Created:");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    println!("• agent_memory.db         - SQLite database");
    println!("• agent_memory.json       - JSON storage");
    println!("• agent_memory.msgpack    - MessagePack storage");
    println!("• backup.json             - Migrated data");
    println!("• exported_memory.json    - Exported snapshot");
    println!("• exported_memory.msgpack - Exported snapshot (binary)\n");

    println!("✅ Example completed successfully!");
    println!("\n💡 Tip: Check the created files to see your persisted data!");
    println!("   Try running this example again - your SQLite data will persist!");
}

impl TaskRequest

pub fn id(&self) -> &str

Returns the unique ID of this task.

Examples found in repository

examples/02_with_tools.rs (line 164)

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

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

    agent.with_system_prompt(
        "You are a helpful math and text assistant. \
         Use the available tools to help the user. \
         Be clear about what tools you're using and why."
    );

    // Step 2: Register custom tools with the agent
    println!("🔧 Registering tools...");
    agent.add_tool(CalculatorTool);
    agent.add_tool(StringToolTool);
    println!("✓ Tools registered\n");

    // Step 3: Create a task that requires tool usage
    let mut task = TaskRequest::new(
        "Please calculate 25 + 15 + 10, and then tell me the uppercase version of the word 'hello'"
    );
    task.with_name("Complex Task")
        .with_description("A task requiring multiple tools")
        .with_priority(8);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    let response = agent.run(task).await;

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

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

examples/10_file_saving.rs (line 135)

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

    // Define the output directory
    let output_dir = "test/web_project_output";

    // Create the output directory if it doesn't exist
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("❌ Failed to create output directory: {}", e);
        return;
    }
    println!("📁 Output directory: {}/\n", output_dir);

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

    agent.with_system_prompt(
        &format!(
            "You are a helpful assistant that can generate content and save it to files. \
             When asked to create content, generate it and use the file_saver tool to save it. \
             \
             IMPORTANT: All files MUST be saved inside the '{}' directory. \
             For example, to save 'server.js', use '{}/server.js' as the filename. \
             For files in subdirectories, use '{}/src/app.js' format. \
             \
             Be clear about what you're creating and where you're saving it.",
            output_dir, output_dir, output_dir
        )
    );

    // Step 2: Register the file saver tool
    println!("🔧 Registering file saver tool...");
    agent.add_tool(FileSaverTool);
    println!("✓ Tool registered\n");

    // Step 3: Create a task that generates content and saves it
    let mut task = TaskRequest::new(
        &format!(
            "Create a simple web project with a file upload API. Save all files in the '{}' directory:\
             \n1. server.js - A Node.js Express server with POST /upload endpoint\
             \n2. package.json - Package configuration with dependencies\
             \n3. test.http - HTTP test file to test the upload endpoint\
             \n4. README.md - Instructions on how to install and run the server\
             \n\nMake sure ALL files are saved in the '{}' directory!",
            output_dir, output_dir
        )
    );
    task.with_name("Generate and Save Web Project")
        .with_description("Generate a complete web project with file upload API")
        .with_priority(7);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    println!("🔄 Running agent...\n");

    let response = agent.run(task).await;

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

    // Step 6: Verify files were created
    println!("🔍 Checking created files in '{}/'\n", output_dir);

    let expected_files = vec![
        "server.js",
        "package.json",
        "test.http",
        "README.md"
    ];

    let mut created_count = 0;

    for file in &expected_files {
        let file_path = format!("{}/{}", output_dir, file);
        if Path::new(&file_path).exists() {
            created_count += 1;
            println!("✓ {} created successfully", file);

            if let Ok(content) = fs::read_to_string(&file_path) {
                let preview: String = content.chars().take(100).collect();
                println!("  Preview: {}", preview.replace('\n', " "));
            }
        } else {
            println!("⚠ {} not found", file);
        }
    }

    println!("\n📊 Summary: {}/{} expected files created", created_count, expected_files.len());

    // Show directory structure
    println!("\n📂 Directory structure:");
    if let Ok(entries) = fs::read_dir(output_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() {
                if let Some(filename) = path.file_name() {
                    if let Ok(metadata) = entry.metadata() {
                        println!("  - {} ({} bytes)",
                                 filename.to_string_lossy(),
                                 metadata.len());
                    }
                }
            }
        }
    }

    println!("\n✅ Example completed successfully!");
    println!("📁 All files are in: {}/", output_dir);
}

pub fn message(&self) -> Message

Converts the task to an LLM message.

This is used internally by the agent to send the task to the LLM.

pub fn description(&self) -> &str

Returns the task description.