everruns 0.17.26

Build and run durable AI agents in Rust — the application-facing entrypoint to the Everruns agentic framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! A reusable typed capability with metadata, structured errors, execution
//! context, progress, and a non-string result.
//!
//! ```text
//! OPENAI_API_KEY=sk-... cargo run -p everruns --features openai --example advanced_capability
//! ```

use everruns::{Agent, OpenAI, SessionEventKind, capability};

#[derive(capability::Deserialize, capability::JsonSchema)]
#[serde(crate = "everruns::capability::serde")]
#[schemars(crate = "everruns::capability::schemars")]
struct LookupInput {
    sku: String,
}

#[derive(capability::Serialize, capability::JsonSchema)]
#[serde(crate = "everruns::capability::serde")]
#[schemars(crate = "everruns::capability::schemars")]
struct Product {
    sku: String,
    name: String,
    price_cents: u64,
    tags: Vec<String>,
}

struct ProductLookup;

#[capability::async_trait]
impl capability::Handler for ProductLookup {
    type Input = LookupInput;
    type Output = Product;
    type Error = capability::Error;

    fn name(&self) -> &str {
        "lookup_product"
    }

    fn display_name(&self) -> Option<&str> {
        Some("Look up product")
    }

    fn description(&self) -> &str {
        "Look up one product by its exact SKU."
    }

    fn hints(&self) -> capability::Hints {
        capability::Hints::default()
            .readonly(true)
            .idempotent(true)
            .metadata(capability::serde_json::json!({ "domain": "catalog" }))
    }

    async fn execute(
        &self,
        input: Self::Input,
        context: capability::Context,
    ) -> Result<Self::Output, Self::Error> {
        context.progress("Searching the product catalog").await;
        if input.sku != "EVR-42" {
            return Err(
                capability::Error::user("product_not_found", "No product has that SKU")
                    .details(capability::serde_json::json!({ "sku": input.sku })),
            );
        }
        Ok(Product {
            sku: input.sku,
            name: "Everruns Field Guide".into(),
            price_cents: 4200,
            tags: vec!["agents".into(), "rust".into()],
        })
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let catalog = capability::Definition::new(
        "product_catalog",
        "Product catalog",
        "Application-owned product data.",
    )
    .instructions("Use exact SKUs. Never invent catalog entries.")
    .metadata(capability::serde_json::json!({ "owner": "commerce" }))
    .tool(ProductLookup);

    let agent = Agent::builder()
        .name("catalog-assistant")
        .instructions("Answer questions using the product catalog capability.")
        .provider(OpenAI::from_env()?)
        .model("gpt-5.6-terra")
        .capability(catalog)
        .build()?;

    let session = agent.session();
    let mut events = session.events();
    let pending = session.send("What is product EVR-42?").await?;
    while let Some(event) = events.recv().await? {
        if let SessionEventKind::ToolProgress { message, .. } = &event.kind {
            eprintln!("progress: {message}");
        }
        if event.turn_id.as_deref() == Some(&pending.turn_id) && event.kind.is_terminal() {
            break;
        }
    }

    let turn = pending.wait().await?;
    println!("{}", turn.response);
    Ok(())
}