Struct TaskResponse 

pub struct TaskResponse { /* private fields */ }

The response from an agent after completing a task.

Contains the task ID and the output data produced by the agent.

Examples

use ceylon_next::agent::Agent;
use ceylon_next::tasks::{TaskRequest, OutputData};

let mut agent = Agent::new("Assistant", "openai::gpt-4");
let task = TaskRequest::new("Say hello");
let response = agent.run(task).await;

match response.result() {
    OutputData::Text(text) => println!("Agent said: {}", text),
    _ => println!("Non-text response"),
}

Implementations

impl TaskResponse

pub fn result(&self) -> OutputData

Returns a clone of the output data.

Examples

use ceylon_next::tasks::{TaskResponse, OutputData};

let response = TaskResponse::new("task-123", OutputData::Text("Hello".to_string()));
let output = response.result();

Examples found in repository

examples/02_with_tools.rs (line 168)

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 43)

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 133)

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/06_nextjs_app_generator.rs (line 86)

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 174)

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/09_test_groq.rs (line 35)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing Groq LLM Provider with API Key\n");

    // Test 1: Using Agent::new_with_config() - Recommended approach
    println!("{}", "=".repeat(60));
    println!("Test 1: Using Agent::new_with_config() with explicit API key");
    println!("{}", "=".repeat(60));

    match std::env::var("GROQ_API_KEY") {
        Ok(api_key) => {
            println!("✓ GROQ_API_KEY found in environment\n");

            let groq_config = LLMConfig::new("groq::llama-3.3-70b-versatile")
                .with_api_key(api_key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            match Agent::new_with_config("Groq Agent", groq_config) {
                Ok(mut agent) => {
                    println!("✓ Groq agent created successfully!\n");

                    println!("Running task: 'What is 2 + 2?'");
                    let task = TaskRequest::new("What is 2 + 2? Answer in one short sentence.");
                    println!("Sending request to Groq API...\n");

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

                    println!("Response received:");
                    println!("================");
                    println!("{:?}", response.result());
                    println!("================\n");

                    println!("🎉 Test 1 completed successfully!");
                }
                Err(e) => {
                    println!("✗ Failed to create Groq agent: {}\n", e);
                }
            }
        }
        Err(_) => {
            println!("✗ GROQ_API_KEY not found in environment");
            println!("  Please set GROQ_API_KEY to run this test\n");
        }
    }

    // Test 2: Using Agent::new() with environment variable - Simpler approach
    println!("\n{}", "=".repeat(60));
    println!("Test 2: Using Agent::new() with environment variable");
    println!("{}", "=".repeat(60));

    if std::env::var("GROQ_API_KEY").is_ok() {
        println!("✓ GROQ_API_KEY is set, agent will use it automatically\n");

        match std::panic::catch_unwind(|| {
            Agent::new("Simple Groq Agent", "groq::llama-3.3-70b-versatile")
        }) {
            Ok(mut agent) => {
                println!("✓ Groq agent created successfully with auto API key!\n");

                println!("Running task: 'What is the capital of France?'");
                let task = TaskRequest::new("What is the capital of France? Answer in one word.");

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

                println!("Response received:");
                println!("================");
                println!("{:?}", response.result());
                println!("================\n");

                println!("🎉 Test 2 completed successfully!");
            }
            Err(_) => {
                println!("✗ Failed to create agent (unexpected panic)\n");
            }
        }
    } else {
        println!("✗ GROQ_API_KEY not set, skipping this test\n");
    }

    println!("\n{}", "=".repeat(60));
    println!("All tests completed!");
    println!("{}", "=".repeat(60));

    Ok(())
}

Additional examples can be found in:

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

impl TaskResponse

pub fn new(id: &str, output: OutputData) -> Self

Creates a new task response.

Arguments

• id - The ID of the task this is responding to
• output - The output data produced by the agent

impl TaskResponse

pub fn id(&self) -> &str

Returns the ID of the task this response is for.