agentos-client 0.4.2

High-level Rust client SDK for the Agent OS native sidecar (1:1 port of the TypeScript AgentOs client)
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

use agentos_client::{AgentOsLimits, ExecutionLimits, TlsLimits};
use serde_json::json;

#[test]
fn tls_and_execution_limits_round_trip_with_typescript_wire_names() {
    let limits = AgentOsLimits {
        tls: Some(TlsLimits {
            max_buffered_bytes: Some(2048),
        }),
        execution: Some(ExecutionLimits {
            completed_ttl_ms: Some(60_000),
            max_completed_executions: Some(128),
            live_execution_warning_threshold: Some(32),
        }),
        ..Default::default()
    };
    let expected = json!({
        "tls": { "maxBufferedBytes": 2048 },
        "execution": {
            "completedTtlMs": 60_000,
            "maxCompletedExecutions": 128,
            "liveExecutionWarningThreshold": 32
        }
    });
    assert_eq!(serde_json::to_value(&limits).unwrap(), expected);
    assert_eq!(
        serde_json::from_value::<AgentOsLimits>(expected).unwrap(),
        limits
    );
}

#[test]
fn omitted_limit_fields_preserve_sidecar_defaults() {
    assert_eq!(
        serde_json::to_value(AgentOsLimits::default()).unwrap(),
        json!({})
    );
    let empty: AgentOsLimits = serde_json::from_value(json!({"tls": {}, "execution": {}})).unwrap();
    assert_eq!(empty.tls, Some(TlsLimits::default()));
    assert_eq!(empty.execution, Some(ExecutionLimits::default()));
    assert_eq!(
        serde_json::to_value(empty).unwrap(),
        json!({"tls": {}, "execution": {}})
    );
}

#[test]
fn tls_and_execution_limits_reject_unknown_fields_and_noninteger_values() {
    for invalid in [
        json!({"tls": {"max_buffered_bytes": 1024}}),
        json!({"execution": {"completed_ttl_ms": 1024}}),
        json!({"execution": {"unknown": 1}}),
        json!({"tls": {"maxBufferedBytes": -1}}),
        json!({"execution": {"completedTtlMs": 1.5}}),
    ] {
        assert!(
            serde_json::from_value::<AgentOsLimits>(invalid.clone()).is_err(),
            "{invalid}"
        );
    }
}