Rust

// cargo add chronicle-sdk tokio --features tokio/full
use chronicle_sdk::Chronicle;

let client = Chronicle::from_env()?; // reads CHRONICLE_API_KEY and CHRONICLE_API_URL
// or: Chronicle::builder().api_key("chr_...").base_url("https://api.your-chronicle-deployment.com").build()?

use chronicle_sdk::{Chronicle, types::{EvaluationCreateParams, WorldCompileParams, WorldCreateParams}};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Chronicle::from_env()?;
    let example = client.worlds().examples().list().await?.items.into_iter()
        .find(|e| e.blueprint.scenario.tasks.iter().any(|t| t.key == "triage-duplicate-invoice"))
        .ok_or("The duplicate-invoice example is not available")?;
    let preview = client.worlds().compile(WorldCompileParams { blueprint: example.blueprint.clone() }).await?;
    if !preview.problems.is_empty() { return Err(format!("blueprint: {:?}", preview.problems).into()); }

    let world = client.worlds().create(WorldCreateParams {
        blueprint: example.blueprint,
        idempotency_key: "demo-1".into(),
        ..Default::default()
    }).await?;
    let world = client.worlds().wait(&world.world.id, Duration::from_secs(180)).await?;
    if world.status != "ready" {
        return Err(format!("world {}: {:?}; {:?}", world.world.id, world.status, world.launch_error).into());
    }
    let evaluation = world.evaluation.as_ref()
        .filter(|e| e.status == "ready")
        .ok_or_else(|| format!("Task setup is not ready for world {}; see the Worlds guide", world.world.id))?;

    let run = client.evaluations().create(EvaluationCreateParams {
        task_suite_id: evaluation.task_suite_id.clone(),
        agents: vec!["billing-agent@1.0.0".into()],
        idempotency_key: "demo-run-1".into(),
        ..Default::default()
    }).await?;
    let run = client.evaluations().wait(&run.id, Duration::from_secs(600)).await?;
    if run.status != "succeeded" { return Err(format!("evaluation {}: {:?}; inspect its trials", run.id, run.status).into()); }
    for task in client.evaluations().results(&run.id).await?.task_results {
        println!("{} {} {:?}", task.task_id, task.passed, task.failed_scorers);
    }
    Ok(())
}

use chronicle_sdk::types::PageParams;

let mut page = client.evaluations().trials()
    .list(&run.id, PageParams { limit: Some(100), ..Default::default() })
    .await?;
loop {
    for trial in &page.items {
        println!("{} {} {} {:?}", trial.id, trial.agent, trial.task_id, trial.status);
        for score in &trial.scores { println!("{} {:?} {}", score.name, score.score, score.passed); }
    }
    if !page.has_next_page() { break; }
    page = page.get_next_page().await?;
}

let client = Chronicle::builder()
    .timeout(Duration::from_secs(30))
    .max_retries(2)
    .build()?;

match client.worlds().retrieve("<world-id>").await {
    Ok(world) => println!("{}", world.world.id),
    Err(e) => eprintln!("{:?} {} {:?}", e.status_code(), e, e.request_id()),
}