acpx 0.1.0

Simple Rust library and tooling for building on ACP.
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

use futures::executor::block_on;

use acpx::{
    AgentServer, Error, RuntimeContext, UnsupportedLaunch,
    agent_servers::{self, Error as AgentServersError, HostPlatform, VERSION},
};

#[test]
fn agent_server_resolves_official_registry_ids() {
    let codex = agent_servers::get("codex-acp").expect("codex-acp should resolve");
    assert_eq!(codex.id(), "codex-acp");

    let droid = agent_servers::get("factory-droid").expect("factory-droid should resolve");
    assert_eq!(droid.id(), "factory-droid");

    assert!(agent_servers::get("missing-agent").is_none());
    assert!(matches!(
        agent_servers::require("missing-agent"),
        Err(AgentServersError::UnknownServer { id }) if id == "missing-agent"
    ));
}

#[test]
fn agent_servers_match_the_generated_snapshot() {
    let servers = agent_servers::all();
    assert!(!servers.is_empty());
    assert_eq!(agent_servers::version(), VERSION);
    assert!(
        servers
            .iter()
            .any(|agent_server| agent_server.id() == "codex-acp")
    );
    assert!(
        servers
            .iter()
            .any(|agent_server| agent_server.id() == "factory-droid")
    );
    assert!(
        servers
            .iter()
            .any(|agent_server| agent_server.id() == "autohand")
    );
}

#[test]
fn host_platform_mapping_covers_known_registry_targets() {
    assert_eq!(
        HostPlatform::from_target("macos", "aarch64").expect("macOS arm64 should map"),
        HostPlatform::DarwinAarch64
    );
    assert_eq!(
        HostPlatform::from_target("macos", "x86_64").expect("macOS x86_64 should map"),
        HostPlatform::DarwinX86_64
    );
    assert_eq!(
        HostPlatform::from_target("linux", "aarch64").expect("linux arm64 should map"),
        HostPlatform::LinuxAarch64
    );
    assert_eq!(
        HostPlatform::from_target("linux", "x86_64").expect("linux x86_64 should map"),
        HostPlatform::LinuxX86_64
    );
    assert_eq!(
        HostPlatform::from_target("windows", "aarch64").expect("windows arm64 should map"),
        HostPlatform::WindowsAarch64
    );
    assert_eq!(
        HostPlatform::from_target("windows", "x86_64").expect("windows x86_64 should map"),
        HostPlatform::WindowsX86_64
    );
    assert!(matches!(
        HostPlatform::from_target("freebsd", "x86_64"),
        Err(AgentServersError::UnsupportedHostPlatform { os, arch })
            if os == "freebsd" && arch == "x86_64"
    ));
}

#[test]
fn binary_target_resolution_matches_platform_support() {
    let corust_agent_server =
        agent_servers::get("corust-agent").expect("corust-agent should resolve");
    let linux_x86_64_target =
        agent_servers::binary_target_for(&corust_agent_server, HostPlatform::LinuxX86_64)
            .expect("linux x86_64 should exist")
            .expect("binary target should resolve");
    assert_eq!(linux_x86_64_target.target(), "linux-x86_64");

    assert!(matches!(
        agent_servers::binary_target_for(&corust_agent_server, HostPlatform::LinuxAarch64),
        Err(AgentServersError::MissingBinaryTarget { id, target })
            if id == "corust-agent" && target == "linux-aarch64"
    ));

    let autohand_agent_server = agent_servers::get("autohand").expect("autohand should resolve");
    assert!(
        agent_servers::binary_target_for(&autohand_agent_server, HostPlatform::LinuxX86_64)
            .expect("package-backed agent servers should not fail")
            .is_none()
    );
}

#[test]
fn binary_only_generated_servers_return_typed_unsupported_launch_errors() {
    let runtime = RuntimeContext::new(|_| {});
    let amp_agent_server = agent_servers::require("amp-acp").expect("amp-acp should resolve");
    let error = block_on(amp_agent_server.connect(&runtime)).err();

    assert!(matches!(
        error,
        Some(Error::UnsupportedLaunch(
            UnsupportedLaunch::BinaryDistribution
        ))
    ));
}