Swarms Rust v0.3.0：OpenRouter、按名称调用任意模型、子智能体与交接

[dependencies]
swarms-rs = "0.3.0"
tokio = { version = "1", features = ["full"] }
anyhow = "1"

# Only needed if you define tools with #[tool]
swarms-macro = "0.2.0"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
schemars = "0.8"
thiserror = "2"

cargo add swarms-rs@0.3
cargo add tokio --features full
cargo add anyhow

# Only needed if you define tools with #[tool]
cargo add swarms-macro@0.2 serde --features serde/derive
cargo add serde_json thiserror schemars@0.8

export OPENROUTER_API_KEY="sk-or-..."   # OpenRouter
export ANTHROPIC_API_KEY="sk-ant-..."   # Anthropic
export OPENAI_API_KEY="sk-..."          # OpenAI
export DEEPSEEK_API_KEY="sk-..."        # DeepSeek

// 0.2.x
let t: f64 = config.temperature;

// 0.3.0
if let Some(t) = config.temperature {
    println!("temperature: {t}");
}

use swarms_rs::structs::conversation::Content;

match &message.content {
    Content::Text(text) => println!("{text}"),
    Content::ToolCalls { text, outputs, .. } => {
        if let Some(text) = text {
            println!("{text}");
        }
        for output in outputs {
            println!("{} returned {}", output.name, output.result);
        }
    }
}

// 0.2.x
rearrange.add_agent(agent);

// 0.3.0
rearrange.add_agent(agent)?;

use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::agent::Agent;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Reads OPENROUTER_API_KEY
    let agent = OpenRouter::from_env_with_model("anthropic/claude-opus-5.5")
        .with_app_name("my-app") // optional: credit your app on openrouter.ai
        .agent_builder()
        .agent_name("Researcher")
        .system_prompt("You are a concise research assistant.")
        .build();

    let answer = agent.run("What is a vector database?".to_string()).await?;
    println!("{answer}");
    Ok(())
}

use swarms_rs::llm::provider::any::AnyModel;
use swarms_rs::structs::agent::Agent;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    for name in [
        "anthropic/claude-opus-5-5",
        "openai/gpt-5.5",
        "google/gemini-3.8-flash",
    ] {
        let agent = AnyModel::from_model_name(name)?
            .agent_builder()
            .system_prompt("Answer in one sentence.")
            .build();

        let answer = agent.run("What does Rust's borrow checker do?".to_string()).await?;
        println!("{name}: {answer}");
    }
    Ok(())
}

use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::agent::Agent;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = OpenRouter::from_env_with_model("anthropic/claude-opus-5.5");

    // Sub-agent: the coordinator calls it like a tool and uses its answer.
    let researcher = client
        .agent_builder()
        .agent_name("Researcher")
        .description("Looks up facts and returns a short, sourced summary")
        .system_prompt("You are a researcher. Answer with concise facts only.")
        .build();

    // Handoff target: once the coordinator transfers to it, it finishes the task.
    let writer = client
        .agent_builder()
        .agent_name("Writer")
        .description("Writes the final, polished answer for the user")
        .system_prompt("Using the context and conversation you are given, write the final answer.")
        .build();

    let coordinator = client
        .agent_builder()
        .agent_name("Coordinator")
        .system_prompt(
            "Delegate fact-finding to the Researcher, then transfer to the Writer \
             with the facts as context so it can write the answer.",
        )
        .add_sub_agent(researcher)
        .add_handoff(writer)
        .max_loops(4)
        .build();

    let output = coordinator
        .run("Why did Rust adopt async/await instead of green threads?".to_string())
        .await?;
    println!("{output}");
    Ok(())
}

use swarms_macro::tool;
use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::agent::Agent;

#[derive(Debug, thiserror::Error)]
#[error("math error")]
pub struct MathError;

#[tool(description = "Multiply two numbers")]
fn multiply(a: f64, b: f64) -> Result<f64, MathError> {
    Ok(a * b)
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let agent = OpenRouter::from_env_with_model("openai/gpt-5.5")
        .agent_builder()
        .system_prompt("Use the multiply tool for arithmetic.")
        .add_tool(Multiply)
        .build();

    let task = "What is 17 times 23?";
    agent.run(task.to_string()).await?;

    if let Some(conversation) = agent.conversation(task) {
        for output in conversation.tool_outputs() {
            if output.name == "multiply" {
                let product: f64 = output.result_as()?;
                println!("multiply({}) = {product}", output.args);
            }
        }
    }
    Ok(())
}

use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::swarms_router::{SwarmRouter, SwarmRouterConfig, SwarmType};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = OpenRouter::from_env();
    let agents = ["anthropic/claude-opus-5.5", "google/gemini-3.8-flash"]
        .into_iter()
        .map(|model| {
            client
                .clone()
                .set_model(model)
                .agent_builder()
                .agent_name(model)
                .system_prompt("Give one concrete recommendation.")
                .build()
        })
        .collect();

    let mut config = SwarmRouterConfig::with_agents(agents);
    config.swarm_type = SwarmType::ConcurrentWorkflow;
    config.rules = Some("Keep every answer under 100 words.".to_string());

    let router = SwarmRouter::new_with_config(config)?;
    let conversation = router.run("How should a small team version its API?").await?;
    println!("{conversation}");
    Ok(())
}

use swarms_rs::structs::conversation::{AgentConversation, Role};

fn main() -> anyhow::Result<()> {
    let mut conversation = AgentConversation::new("notes".to_string());
    conversation.add(Role::User("Alice".to_string()), "Hello".to_string());

    let json = conversation.to_json()?;

    let mut restored = AgentConversation::new("notes".to_string());
    restored.load_json(&json)?;
    assert_eq!(restored.to_string(), conversation.to_string());
    Ok(())
}

git clone https://github.com/The-Swarm-Corporation/swarms-rs
cd swarms-rs
export OPENROUTER_API_KEY="sk-or-..."
cargo run --example openrouter_model_panel

use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::agent::Agent;
use swarms_rs::structs::concurrent_workflow::ConcurrentWorkflow;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = OpenRouter::from_env();
    let models = ["anthropic/claude-opus-5.5", "openai/gpt-5.5", "google/gemini-3.8-flash"];

    let agents: Vec<Box<dyn Agent>> = models
        .iter()
        .map(|model| {
            Box::new(
                client
                    .clone()
                    .set_model(*model)
                    .agent_builder()
                    .agent_name(*model)
                    .system_prompt("Answer in at most three sentences and commit to a position.")
                    .build(),
            ) as Box<dyn Agent>
        })
        .collect();

    let workflow = ConcurrentWorkflow::builder()
        .name("ModelPanel")
        .agents(agents)
        .build();

    let result = workflow
        .run("Should a new backend service start as a monolith or as microservices?")
        .await?;
    for message in &result.history {
        println!("── {} ──\n{}\n", message.role, message.content);
    }
    Ok(())
}

use swarms_rs::llm::provider::openrouter::OpenRouter;
use swarms_rs::structs::agent::Agent;
use swarms_rs::structs::sequential_workflow::SequentialWorkflow;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = OpenRouter::from_env();
    let stage = |model: &str, name: &str, prompt: &str| -> Box<dyn Agent> {
        Box::new(
            client
                .clone()
                .set_model(model)
                .agent_builder()
                .agent_name(name)
                .system_prompt(prompt)
                .build(),
        )
    };

    let workflow = SequentialWorkflow::builder()
        .name("OpenRouterPipeline")
        .agents(vec![
            stage("google/gemini-3.8-flash", "Researcher", "List the key facts as bullet points."),
            stage("anthropic/claude-opus-5.5", "Writer", "Turn the notes into a 300-word article."),
            stage("openai/gpt-5.5", "Editor", "Fix errors and return only the final article."),
        ])
        .build();

    let result = workflow.run("How Rust's borrow checker prevents data races").await?;
    if let Some(article) = result.history.last() {
        println!("{}", article.content);
    }
    Ok(())
}