a3s-code-core 9.0.0

A3S Code Core - Embeddable AI agent library with tool execution
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

//! S-AP-01: a cancelled run stays terminal when a later start is recorded.

use super::{InMemoryRunStore, RunStatus};
use crate::agent::AgentEvent;

const CYCLES: usize = 30;

#[tokio::test]
#[ignore = "S-AP-01 soak: 30 start/tool/cancel/recover cycles"]
async fn soak_cancelled_runs_stay_terminal_and_do_not_leak_sessions() {
    let store = InMemoryRunStore::new();

    for cycle in 0..CYCLES {
        let run = store
            .create_run("protocol-soak", &format!("cycle-{cycle}"))
            .await;
        let started = store
            .record_event(
                &run.id,
                AgentEvent::Start {
                    prompt: format!("start-{cycle}"),
                },
            )
            .await
            .expect("start is recorded");
        assert_eq!(started.status, RunStatus::Executing);
        let tooled = store
            .record_event(
                &run.id,
                AgentEvent::ToolExecutionStart {
                    id: format!("tool-{cycle}"),
                    name: "read".into(),
                    args: serde_json::json!({ "path": "fixture.txt" }),
                },
            )
            .await
            .expect("tool start is recorded");
        assert!(
            tooled.event_count > started.event_count,
            "cycle {cycle} tool event did not advance the sequence"
        );

        let cancelled = store.mark_cancelled(&run.id).await.expect("cancel");
        assert_eq!(cancelled.status, RunStatus::Cancelled);

        let recovered = store
            .record_event(
                &run.id,
                AgentEvent::Start {
                    prompt: format!("recover-{cycle}"),
                },
            )
            .await
            .expect("recovery event is retained for replay");
        assert_eq!(
            recovered.status,
            RunStatus::Cancelled,
            "cycle {cycle} returned a cancelled run to a live status"
        );
        assert!(recovered.status.is_terminal());

        let events = store.events(&run.id).await;
        assert!(events.len() >= 3, "cycle {cycle} dropped an event");
        for pair in events.windows(2) {
            assert!(
                pair[1].sequence > pair[0].sequence,
                "cycle {cycle} event sequence regressed: {} then {}",
                pair[0].sequence,
                pair[1].sequence
            );
        }
    }
}