theway-core 0.1.21

theway core — stateful agent runtime + harness (Agent loop, skills, prompt templates, sessions, compaction) on top of theway-llm-provider.
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

use super::*;

#[tokio::test]
async fn wait_for_runs_returns_on_completion() {
    let (engine, _launcher) = engine_with_launcher();
    let run = engine
        .plan(
            run_def("t", None, None, &[("a", "x", "t", &[])]),
            None,
            None,
        )
        .unwrap();
    let id = run.id.clone();
    let waiter_id = id.clone();
    let engine2 = engine.clone();
    let waiter = tokio::spawn(async move {
        engine2
            .wait_for_runs(&[waiter_id], Duration::from_secs(5), None)
            .await
    });
    tokio::time::sleep(Duration::from_millis(50)).await;
    engine.on_node_completed(&id, "a", ok_outcome());
    let results = waiter.await.unwrap();
    assert_eq!(results, vec![(id, false)]);
}

#[tokio::test]
async fn wait_for_runs_times_out_and_multi_run() {
    let (engine, _launcher) = engine_with_launcher();
    let r1 = engine
        .plan(
            run_def("t1", None, None, &[("a", "x", "t", &[])]),
            None,
            None,
        )
        .unwrap();
    let r2 = engine
        .plan(
            run_def("t2", None, None, &[("b", "x", "t", &[])]),
            None,
            None,
        )
        .unwrap();
    let id1 = r1.id.clone();
    let id2 = r2.id.clone();
    engine.on_node_completed(&id1, "a", ok_outcome());
    // r1 terminal → immediate; r2 never completes → timed out.
    let results = engine
        .wait_for_runs(
            &[id1.clone(), id2.clone()],
            Duration::from_millis(100),
            None,
        )
        .await;
    assert_eq!(results, vec![(id1, false), (id2, true)]);
}

#[tokio::test]
async fn wait_for_runs_idle_watchdog() {
    let (engine, _launcher) = engine_with_launcher();
    let run = engine
        .plan(
            run_def("t", None, None, &[("a", "x", "t", &[])]),
            None,
            None,
        )
        .unwrap();
    let results = engine
        .wait_for_runs(
            std::slice::from_ref(&run.id),
            Duration::from_secs(10),
            Some(Duration::from_millis(80)),
        )
        .await;
    assert_eq!(results, vec![(run.id, true)]);
}