agentai 0.3.2

AgentAI is a Rust library designed to simplify the creation of AI agents.
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

//! Streaming Example
//!
//! This example streams the agent's answer and prints it as the model writes it. The question
//! needs the built-in date and time tools, so the stream also shows the tool calls and their
//! results before the final answer.

use agentai::tool::buildin::CurrentDateAndTimeToolBox;
use agentai::{Agent, AgentEvent, Message};
use anyhow::Result;
use futures_util::StreamExt;
use std::io::Write;

const SYSTEM: &str = "You are helpful assistant. Use tools when you need the current date or time.";

#[tokio::main]
async fn main() -> Result<()> {
    // The provider comes from the model name, for example `claude-haiku-5-5` or
    // `omlx::Qwen3.8-27B-4bit`; its API key and endpoint come from the provider's environment
    // variables, for example `ANTHROPIC_API_KEY` or `OMLX_ENDPOINT`.
    let model = std::env::var("AGENTAI_MODEL").unwrap_or("claude-haiku-5-5".to_string());

    let agent = Agent::new(SYSTEM)?
        .with_model(&model)
        .with_toolbox(CurrentDateAndTimeToolBox {});

    let mut history: Vec<Message> = Vec::new();
    let question = "What day of the week is it today? Answer with a short poem about it.";
    println!("Question: {question}\n");

    // The stream is `Send + 'static`, so it could also be moved into a spawned task.
    // Reading the events yourself gives full control. To just write the stream to stdout (or a
    // file, or any other `std::io::Write`), replace the loop with
    // `stream.print_to(std::io::stdout()).await?` (`print_to_async` and `print_to_tokio` for async
    // writers). To change what is written, or to show the run elsewhere (a GUI, a log), pass a
    // configured `agentai::listener::Printer` or your own `EventListener` to `stream.listen(..)`.
    let mut stream = agent
        .run_stream::<String>(question)
        .with_history(&history)
        .await?;
    while let Some(event) = stream.next().await {
        match event? {
            AgentEvent::TextDelta(text) => {
                print!("{text}");
                std::io::stdout().flush()?;
            }
            AgentEvent::ToolCall(call) => {
                println!("[tool call] {}({})", call.name, call.arguments)
            }
            AgentEvent::ToolResult { tool, content, .. } => {
                println!("[tool result] {tool}: {content}")
            }
            AgentEvent::Finished(result) => {
                println!(
                    "\n\nDone after {} model calls, {:?} tokens",
                    result.iterations, result.usage.total_tokens
                );
                history.extend(result.new_messages);
            }
            _ => {}
        }
    }

    println!("The history has {} messages", history.len());

    Ok(())
}