AgentBuilder API

use mofa_runtime::AgentBuilder;

let runtime = AgentBuilder::new("agent-1", "My Agent")
    .with_capability("chat")
    .with_capability("summarization")
    .with_plugin(Box::new(llm_plugin))
    .with_max_concurrent_tasks(20)
    .with_timeout(Duration::from_secs(60))
    .with_agent(my_agent)
    .await?;

let builder = AgentBuilder::new("assistant-1", "AI Assistant");

let builder = builder
    .with_capability("chat")
    .with_capability("vision")
    .with_capability("tool_use");

let builder = builder.with_capabilities(vec![
    "chat",
    "summarization",
    "translation",
]);

let builder = builder
    .with_dependency("storage-agent")
    .with_dependency("tool-registry");

let builder = builder
    .with_plugin(Box::new(llm_plugin))
    .with_plugin(Box::new(storage_plugin))
    .with_plugin(Box::new(tool_plugin));

let builder = builder
    .with_input("user_messages")
    .with_input("system_events");

let builder = builder
    .with_output("responses")
    .with_output("logs");

let builder = builder.with_max_concurrent_tasks(50);

let builder = builder.with_timeout(Duration::from_secs(120));

let builder = builder
    .with_config("log_level", "debug")
    .with_config("enable_metrics", "true");

let config = builder.build_config();
println!("Agent ID: {}", config.agent_id);
println!("Name: {}", config.name);

let metadata = builder.build_metadata();
println!("Capabilities: {:?}", metadata.capabilities);
println!("State: {:?}", metadata.state);

// Non-Dora mode: Returns SimpleAgentRuntime
let runtime = builder.with_agent(my_agent).await?;

// Dora mode: Returns AgentRuntime
let runtime = builder.with_agent(my_agent).await?;

let runtime = builder.build_and_start(my_agent).await?;
// Agent is now running and ready to process events

use mofa_runtime::AgentBuilder;
use mofa_foundation::llm::{LLMPlugin, OpenAIProvider, OpenAIConfig};
use mofa_plugins::tool::ToolPluginAdapter;
use std::sync::Arc;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Create plugins
    let llm_config = OpenAIConfig::new("sk-...")
        .with_model("gpt-4");
    let llm_provider = Arc::new(OpenAIProvider::new(llm_config));
    let llm_plugin = LLMPlugin::new("openai", llm_provider);

    let calculator = Arc::new(CalculatorTool::new());
    let tool_plugin = ToolPluginAdapter::new(calculator);

    // 2. Create agent implementation
    let agent = MyAgent::new();

    // 3. Build and start runtime
    let runtime = AgentBuilder::new("assistant", "AI Assistant")
        // Capabilities
        .with_capabilities(vec![
            "chat",
            "tool_use",
            "reasoning",
        ])
        // Dependencies
        .with_dependency("storage-service")
        // Plugins
        .with_plugin(Box::new(llm_plugin))
        .with_plugin(Box::new(tool_plugin))
        // I/O ports (Dora mode)
        .with_input("user_input")
        .with_output("agent_output")
        // Runtime config
        .with_max_concurrent_tasks(30)
        .with_timeout(Duration::from_secs(90))
        .with_config("log_level", "info")
        .with_config("enable_tracing", "true")
        // Build and start
        .build_and_start(agent)
        .await?;

    println!("Agent {} started", runtime.metadata().id);

    // 4. Inject events (Simple mode)
    #[cfg(not(feature = "dora"))]
    {
        let event = AgentEvent::TaskReceived(TaskRequest {
            task_id: "task-1".to_string(),
            content: "Hello!".to_string(),
        });
        runtime.inject_event(event).await?;
    }

    // 5. Send messages (Dora mode)
    #[cfg(feature = "dora")]
    {
        let message = AgentMessage::TaskRequest {
            task_id: "task-1".to_string(),
            content: "Analyze this data".to_string(),
        };
        runtime.send_output("agent_output", &message).await?;
    }

    Ok(())
}

pub struct AgentConfig {
    pub agent_id: String,
    pub name: String,
    pub node_config: HashMap<String, String>,
}

pub struct AgentMetadata {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub version: Option<String>,
    pub capabilities: AgentCapabilities,
    pub state: AgentState,
}

pub struct DoraNodeConfig {
    pub node_id: String,
    pub name: String,
    pub inputs: Vec<String>,
    pub outputs: Vec<String>,
    pub event_buffer_size: usize,
    pub default_timeout: Duration,
    pub custom_config: HashMap<String, String>,
}

let runtime: SimpleAgentRuntime<MyAgent> = builder
    .with_agent(my_agent)
    .await?;

let runtime: AgentRuntime<MyAgent> = builder
    .with_agent(my_agent)
    .await?;

impl MyApp {
    async fn create_agent(&self) -> Result<SimpleAgentRuntime<MyAgent>> {
        let builder = AgentBuilder::new(&self.agent_id, &self.agent_name);
        
        let builder = if self.enable_llm {
            builder.with_plugin(Box::new(self.create_llm_plugin()?))
        } else {
            builder
        };
        
        let builder = if self.enable_tools {
            builder
                .with_plugin(Box::new(self.create_tool_plugin()?))
                .with_capability("tool_use")
        } else {
            builder
        };
        
        builder
            .with_max_concurrent_tasks(self.max_tasks)
            .with_timeout(self.timeout)
            .build_and_start(self.create_agent_impl())
            .await
    }
}