thal 0.0.1

Reactive semantic runtime — molecules, reactions, and effect actors for building LLM-backed applications as dataflow programs.
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

use std::time::{Duration, Instant};
use thal::value::Value;
use thal::Reactor;

const PROGRAM: &str = r#"
reaction Echo {
    when:  Tick(t)
    where: t.sequence == 1
    emit:  Process { cmd: "echo", args: ["hello, thal"] }
}

reaction Init {
    when: Boot(b)
    emit: Timer { interval: 50ms }
}
"#;

#[tokio::test(flavor = "multi_thread")]
async fn process_actor_runs_echo() {
    let program = thal::load_str(PROGRAM).expect("load");
    let reactor = Reactor::new(program);
    let store = reactor.store();
    let task = tokio::spawn(reactor.run());

    // Poll until a Process molecule transitions to Done, with a deadline.
    let deadline = Instant::now() + Duration::from_millis(500);
    loop {
        if Instant::now() > deadline {
            break;
        }
        let processes = store.scan_by_name("Process");
        if processes
            .iter()
            .any(|p| matches!(p.fields.get("status"), Some(Value::String(s)) if s == "Done"))
        {
            break;
        }
        tokio::time::sleep(Duration::from_millis(10)).await;
    }
    task.abort();

    let processes = store.scan_by_name("Process");
    assert_eq!(
        processes.len(),
        1,
        "expected exactly one Process molecule, got {}",
        processes.len()
    );

    let p = &processes[0];
    assert_eq!(p.fields["cmd"], Value::String("echo".into()));
    assert_eq!(
        p.fields["status"],
        Value::String("Done".into()),
        "actor should have driven Pending -> Done"
    );
    assert_eq!(p.fields["exit_code"], Value::Int(0));

    let stdout = p.fields["stdout"]
        .as_string()
        .expect("stdout is a String");
    assert!(
        stdout.contains("hello, thal"),
        "expected echo output to contain the argument, got {stdout:?}"
    );

    // List literal round-trip: args should come back as a list of one string.
    match &p.fields["args"] {
        Value::List(items) => {
            assert_eq!(items.len(), 1);
            assert_eq!(items[0], Value::String("hello, thal".into()));
        }
        other => panic!("expected args to be a List, got {}", other.type_name()),
    }
}