#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentCapabilities {
    pub tags: HashSet<String>,
    pub input_types: HashSet<InputType>,
    pub output_types: HashSet<OutputType>,
    pub max_context_length: Option<usize>,
    pub reasoning_strategies: Vec<ReasoningStrategy>,
    pub supports_streaming: bool,
    pub supports_conversation: bool,
    pub supports_tools: bool,
    pub supports_coordination: bool,
    pub custom: HashMap<String, serde_json::Value>,
}

impl AgentCapabilities {
    pub fn new() -> Self;
    pub fn builder() -> AgentCapabilitiesBuilder;
}

use mofa_sdk::kernel::{AgentCapabilities, InputType, OutputType, ReasoningStrategy};

let caps = AgentCapabilities::builder()
    .tag("llm")
    .tag("coding")
    .tag("assistant")
    .input_type(InputType::Text)
    .output_type(OutputType::Text)
    .output_type(OutputType::Json)
    .max_context_length(128000)
    .reasoning_strategy(ReasoningStrategy::ReAct { max_iterations: 10 })
    .supports_streaming(true)
    .supports_conversation(true)
    .supports_tools(true)
    .custom("model", json!("gpt-4o"))
    .build();

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentRequirements {
    pub required_tags: HashSet<String>,
    pub preferred_tags: HashSet<String>,
    pub input_types: HashSet<InputType>,
    pub output_types: HashSet<OutputType>,
    pub requires_streaming: bool,
    pub requires_tools: bool,
    pub requires_conversation: bool,
    pub requires_coordination: bool,
}

impl AgentRequirements {
    pub fn new() -> Self;
    pub fn builder() -> AgentRequirementsBuilder;
}

use mofa_sdk::kernel::{AgentRequirements, InputType, OutputType};

let requirements = AgentRequirements::builder()
    .require_tag("llm")           // Must have
    .prefer_tag("coding")         // Nice to have
    .prefer_tag("research")
    .require_input(InputType::Text)
    .require_output(OutputType::Text)
    .require_tools()
    .require_streaming()
    .build();

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[non_exhaustive]
pub enum ReasoningStrategy {
    #[default]
    Direct,
    ReAct { max_iterations: usize },
    ChainOfThought,
    TreeOfThought { branching_factor: usize },
    Custom(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum InputType {
    Text,
    Image,
    Audio,
    Video,
    Structured(String),
    Binary,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum OutputType {
    Text,
    Json,
    StructuredJson,
    Stream,
    Binary,
    Multimodal,
}

use mofa_sdk::kernel::{
    AgentCapabilities, InputType, OutputType, ReasoningStrategy
};
use serde_json::json;

// LLM coding assistant
let coding_agent_caps = AgentCapabilities::builder()
    .tags(vec!["llm", "coding", "rust"])
    .input_type(InputType::Text)
    .output_type(OutputType::Text)
    .output_type(OutputType::Json)
    .max_context_length(128000)
    .reasoning_strategy(ReasoningStrategy::ChainOfThought)
    .supports_streaming(true)
    .supports_conversation(true)
    .supports_tools(true)
    .custom("programming_languages", json!(["rust", "python", "go"]))
    .build();

// Research assistant
let research_agent_caps = AgentCapabilities::builder()
    .tags(vec!["llm", "research", "web-search"])
    .input_type(InputType::Text)
    .output_type(OutputType::Text)
    .reasoning_strategy(ReasoningStrategy::ReAct { max_iterations: 15 })
    .supports_tools(true)
    .supports_conversation(true)
    .custom("search_engines", json!(["google", "bing"]))
    .build();

use mofa_sdk::kernel::{AgentRequirements, InputType};

let requirements = AgentRequirements::builder()
    .require_tag("llm")
    .require_tag("coding")
    .prefer_tag("rust")
    .require_input(InputType::Text)
    .require_tools()
    .build();

// Check if agent matches
if coding_agent_caps.matches(&requirements) {
    let score = coding_agent_caps.match_score(&requirements);
    println!("Coding agent matches! Score: {:.2}", score);
}

if research_agent_caps.matches(&requirements) {
    let score = research_agent_caps.match_score(&requirements);
    println!("Research agent matches! Score: {:.2}", score);
} else {
    println!("Research agent doesn't match requirements");
}

use mofa_sdk::kernel::{AgentCapabilities, AgentRequirements};
use std::collections::HashMap;

struct AgentRegistry {
    agents: HashMap<String, AgentCapabilities>,
}

impl AgentRegistry {
    fn find_best_match(&self, requirements: &AgentRequirements) -> Option<String> {
        self.agents
            .iter()
            .filter(|(_, caps)| caps.matches(requirements))
            .max_by(|(_, caps_a), (_, caps_b)| {
                caps_a.match_score(requirements)
                    .partial_cmp(&caps_b.match_score(requirements))
                    .unwrap()
            })
            .map(|(id, _)| id.clone())
    }
}

// Usage
let mut registry = AgentRegistry { agents: HashMap::new() };
registry.agents.insert("coding-agent".to_string(), coding_agent_caps);
registry.agents.insert("research-agent".to_string(), research_agent_caps);

if let Some(agent_id) = registry.find_best_match(&requirements) {
    println!("Best match: {}", agent_id);
}