basis 0.18.0

The basis SDK: workspace discovery, run lifecycle, one event stream, and the two seams. No protocol, no transport, no TTY.
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
113
114
115

//! ADR-0037: a host answers `@<name>` with a resolver of its own, asked
//! before the set the workspace's files configure, and given the hook that
//! keeps what `spawn` teaches current.

use std::sync::{Arc, Mutex};

use basis::{
    AgentResolver, Resolved, Route, Taught, TaughtAgent, Unresolved, agents::OnChange, async_trait,
};

use crate::support::{CardServer, a2a_file, offline_runtime, pinned, write};

/// A registry that knows one agent and remembers the hook it was given.
struct Registry {
    name: &'static str,
    base: String,
    hook: Mutex<Option<OnChange>>,
}

#[async_trait]
impl AgentResolver for Registry {
    async fn resolve(&self, name: &str) -> Result<Resolved, Unresolved> {
        if name != self.name {
            return Err(Unresolved::Unknown);
        }
        let config = basis::A2aAgentConfig::new(name, &self.base);
        let client = mentra::a2a::A2aClient::connect(&config)
            .await
            .map(Arc::new)
            .map_err(|error| Unresolved::Unreachable {
                error: error.to_string(),
                retry_in: None,
            })?;
        Ok(Resolved::over_a2a(client, name))
    }

    fn route(&self, name: &str) -> Route {
        if name == self.name {
            Route::Known
        } else {
            Route::Unknown
        }
    }

    fn taught(&self) -> Taught {
        Taught::default().with_agent(TaughtAgent::new(self.name).with_summary("From the registry."))
    }

    fn on_change(&self, hook: OnChange) {
        *self.hook.lock().unwrap() = Some(hook);
    }
}

#[tokio::test]
async fn a_hosts_resolver_is_reported_first_and_the_file_still_counts() {
    let server = CardServer::start();
    let dir = tempfile::tempdir().unwrap();
    write(
        &dir.path().join(".basis/a2a.json"),
        &a2a_file(&[("nous", &server.base)]),
    );
    let registry = Arc::new(Registry {
        name: "reviewer",
        base: server.base.clone(),
        hook: Mutex::new(None),
    });

    let workspace = pinned(dir.path(), offline_runtime())
        .with_agent_resolver(Arc::clone(&registry) as Arc<dyn AgentResolver>)
        .open()
        .await
        .expect("opens");

    assert_eq!(
        workspace.remote_agents(),
        ["reviewer", "nous"],
        "what the host resolves, then what the file configures"
    );
    assert!(
        registry.hook.lock().unwrap().is_some(),
        "the resolver was given the hook that recaptures descriptions"
    );
    assert_eq!(
        server.fetches(),
        1,
        "the registry connects on resolve, not at open; the file's agent connected at open"
    );
}

#[tokio::test]
async fn a_hosts_resolver_outranks_the_file_by_name() {
    let server = CardServer::start();
    let dir = tempfile::tempdir().unwrap();
    write(
        &dir.path().join(".basis/a2a.json"),
        &a2a_file(&[("reviewer", &server.base)]),
    );
    let registry = Arc::new(Registry {
        name: "reviewer",
        base: server.base.clone(),
        hook: Mutex::new(None),
    });

    let workspace = pinned(dir.path(), offline_runtime())
        .with_agent_resolver(registry)
        .open()
        .await
        .expect("opens");

    assert_eq!(
        workspace.remote_agents(),
        ["reviewer"],
        "one name is one agent, and the host's answer is the one that resolves"
    );
}