phi-agent 0.16.0

phi-agent — Rust AI Agent runtime framework: orchestration, sessions, streaming built-in. You define tools, prompts, domain knowledge.
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
110
111
112

//! Benchmarks: RuntimeEvent → JSON serialization throughput.

use agent_base::{RuntimeEvent, SessionId};
use criterion::{Criterion, black_box, criterion_group, criterion_main};
use phi_agent::event_log::{event_to_jsonl, event_to_value};

fn make_thought_event(sid: &SessionId) -> RuntimeEvent {
    RuntimeEvent::ThoughtDelta {
        session_id: sid.clone(),
        text: "Let me analyze the code structure carefully...".repeat(5),
        agent_id: None,
        trace_id: None,
    }
}

fn make_tool_start_event(sid: &SessionId) -> RuntimeEvent {
    RuntimeEvent::ToolCallStarted {
        session_id: sid.clone(),
        tool_name: "read_file".into(),
        args_json: r#"{"path":"/src/main.rs","offset":0,"limit":500}"#.into(),
        agent_id: None,
        trace_id: None,
    }
}

fn make_tool_finish_event(sid: &SessionId) -> RuntimeEvent {
    RuntimeEvent::ToolCallFinished {
        session_id: sid.clone(),
        tool_name: "read_file".into(),
        summary: format!("Read {} bytes", "fn main() {}\n".repeat(20).len()),
        agent_id: None,
        trace_id: None,
        denied: false,
        details: None,
    }
}

fn bench_event_to_jsonl(c: &mut Criterion) {
    let sid = SessionId::new(1);
    let events = [make_thought_event(&sid), make_tool_start_event(&sid), make_tool_finish_event(&sid)];

    c.bench_function("serialization/jsonl_batch_3", |b| {
        b.iter(|| {
            let mut total = 0usize;
            for event in &events {
                total += event_to_jsonl(event).len();
            }
            black_box(total);
        });
    });
}

fn bench_event_to_value(c: &mut Criterion) {
    let sid = SessionId::new(2);
    let event = make_tool_finish_event(&sid);

    c.bench_function("serialization/to_value", |b| {
        b.iter(|| {
            black_box(event_to_value(&event));
        });
    });
}

fn bench_jsonl_bulk(c: &mut Criterion) {
    // 150 events — realistic turn
    let sid = SessionId::new(3);
    let events: Vec<RuntimeEvent> = (0..50)
        .flat_map(|i| {
            vec![
                RuntimeEvent::ThoughtDelta {
                    session_id: sid.clone(),
                    text: format!("Step {}: thinking...", i),
                    agent_id: None,
                    trace_id: None,
                },
                RuntimeEvent::ToolCallStarted {
                    session_id: sid.clone(),
                    tool_name: "search".into(),
                    args_json: format!(r#"{{"query":"pattern {}"}}"#, i),
                    agent_id: None,
                    trace_id: None,
                },
                RuntimeEvent::ToolCallFinished {
                    session_id: sid.clone(),
                    tool_name: "search".into(),
                    summary: format!("Found results for query {}", i),
                    agent_id: None,
                    trace_id: None,
                    denied: false,
                    details: None,
                },
            ]
        })
        .collect();

    c.bench_function("serialization/jsonl_bulk_150", |b| {
        b.iter(|| {
            let mut total = 0usize;
            for event in &events {
                total += event_to_jsonl(event).len();
            }
            black_box(total);
        });
    });
}

criterion_group! {
    name = serialization_benches;
    config = Criterion::default().sample_size(500);
    targets = bench_event_to_jsonl, bench_event_to_value, bench_jsonl_bulk
}
criterion_main!(serialization_benches);