awaken-runtime 0.6.0

Phase-based execution engine, plugin system, and agent loop for Awaken
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

//! Integration test for `AgentRuntimeBuilder::with_commit_coordinator` (ADR-0036).

use std::sync::Arc;

use async_trait::async_trait;
use awaken_runtime::builder::AgentRuntimeBuilder;
use awaken_runtime_contract::contract::commit_coordinator::{
    CommitCoordinator, CommitError, ThreadCommit, ThreadCommitOutcome, TransactionScopeId,
};
use awaken_runtime_contract::contract::storage::RuntimeCheckpointStore;
use awaken_server_contract::contract::storage::{ThreadRunCheckpointStore, ThreadRunStore};
use awaken_stores::InMemoryStore;

struct NoopCoord {
    thread_run: Arc<InMemoryStore>,
}

impl Default for NoopCoord {
    fn default() -> Self {
        Self {
            thread_run: Arc::new(InMemoryStore::new()),
        }
    }
}

#[async_trait]
impl CommitCoordinator for NoopCoord {
    fn scope(&self) -> TransactionScopeId {
        TransactionScopeId::new("test::noop").unwrap()
    }

    fn reader(&self) -> Arc<dyn RuntimeCheckpointStore> {
        Arc::new(ThreadRunCheckpointStore::new(
            Arc::clone(&self.thread_run) as Arc<dyn ThreadRunStore>
        ))
    }

    async fn commit_checkpoint(
        &self,
        _plan: ThreadCommit,
    ) -> Result<ThreadCommitOutcome, CommitError> {
        Ok(ThreadCommitOutcome)
    }
}

#[test]
fn builder_wires_commit_coordinator_into_runtime() {
    let runtime = AgentRuntimeBuilder::new()
        .with_commit_coordinator(Arc::new(NoopCoord::default()))
        .build()
        .unwrap();
    let coord = runtime
        .commit_coordinator()
        .expect("coordinator should be wired");
    assert_eq!(coord.scope().as_str(), "test::noop");
}

/// Per-run coordinator override plumbing: `RunActivation`'s
/// `with_commit_coordinator_override` attaches the server staging coordinator
/// for one run, which the runtime prefers over its build-time coordinator. The
/// runtime never observes a canonical-event staging buffer.
#[test]
fn run_activation_accepts_commit_coordinator_override() {
    use awaken_runtime::RunActivation;

    let coordinator: Arc<dyn CommitCoordinator> = Arc::new(NoopCoord::default());
    let activation = RunActivation::new("t-override", Vec::new())
        .with_commit_coordinator_override(Arc::clone(&coordinator));

    let attached = activation
        .control
        .commit_coordinator_override
        .as_ref()
        .expect("override must be attached to RunActivation");
    assert!(Arc::ptr_eq(attached, &coordinator));

    // A neutral activation carries no override.
    let neutral = RunActivation::new("t-neutral", Vec::new());
    assert!(neutral.control.commit_coordinator_override.is_none());
}