vv-agent 0.8.0

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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
116
117
118
119
120
121
122
123

use vv_agent::app_server::protocol::{
    generate_app_server_json_schema_bundle, generate_app_server_typescript_bundle,
};

fn envelope_variants(schema: &str) -> Vec<serde_json::Value> {
    serde_json::from_str::<serde_json::Value>(schema)
        .expect("valid schema")
        .get("oneOf")
        .and_then(serde_json::Value::as_array)
        .expect("oneOf variants")
        .clone()
}

#[test]
fn json_schema_bundle_contains_protocol_envelopes() {
    let bundle = generate_app_server_json_schema_bundle().expect("schema bundle");
    assert!(bundle.contains_key("ClientRequest"));
    assert!(bundle.contains_key("ServerNotification"));
    assert!(bundle.contains_key("ServerRequest"));
    assert!(bundle.contains_key("JsonRpcMessage"));
    assert!(bundle.contains_key("TurnResumeParams"));
    assert!(bundle.contains_key("TurnResumeResponse"));
    let approval = bundle
        .get("ApprovalDecision")
        .expect("approval decision schema");
    for decision in ["allow", "allow_session", "deny", "timeout"] {
        assert!(approval.contains(&format!("\"{decision}\"")));
    }
    let resolve: serde_json::Value = serde_json::from_str(
        bundle
            .get("ApprovalResolveParams")
            .expect("approval resolution schema"),
    )
    .expect("valid approval resolution schema");
    assert_eq!(resolve["properties"]["reason"]["type"], "string");
    assert_eq!(resolve["properties"]["metadata"]["type"], "object");
    assert!(!resolve["required"]
        .as_array()
        .expect("required fields")
        .iter()
        .any(|field| field == "reason" || field == "metadata"));

    let resume: serde_json::Value = serde_json::from_str(
        bundle
            .get("TurnResumeResponse")
            .expect("turn resume response schema"),
    )
    .expect("valid turn resume response schema");
    for sensitive in [
        "runDefinition",
        "runDefinitionDigest",
        "operationArguments",
        "operationResponse",
        "extensionState",
        "idempotencyKey",
    ] {
        assert!(
            !resume["properties"]
                .as_object()
                .expect("resume properties")
                .contains_key(sensitive),
            "sensitive field entered resume schema: {sensitive}"
        );
    }
}

#[test]
fn typescript_bundle_contains_generated_protocol_types() {
    let bundle = generate_app_server_typescript_bundle().expect("typescript bundle");
    assert!(bundle.contains_key("ClientRequest.ts"));
    assert!(bundle.contains_key("ServerNotification.ts"));
    assert!(bundle.contains_key("ServerRequest.ts"));
    assert!(bundle.contains_key("TurnResumeParams.ts"));
    assert!(bundle.contains_key("TurnResumeResponse.ts"));
    assert!(bundle
        .get("ApprovalDecision.ts")
        .expect("approval decision TypeScript")
        .contains("allow_session"));
    let resume = bundle
        .get("TurnResumeResponse.ts")
        .expect("turn resume TypeScript");
    assert!(resume.contains("interface TurnResumeResponse"));
    assert!(resume.contains("method: \"turn/resume\""));
}

#[test]
fn request_schemas_are_real_json_rpc_envelopes() {
    let bundle = generate_app_server_json_schema_bundle().expect("schema bundle");

    for variant in envelope_variants(bundle.get("ClientRequest").expect("client schema")) {
        let properties = variant["properties"].as_object().expect("properties");
        let required = variant["required"].as_array().expect("required");
        assert_eq!(properties["jsonrpc"]["const"], "2.0");
        assert!(required.iter().any(|field| field == "jsonrpc"));
        let method = properties["method"]["const"].as_str().expect("method");
        if method == "initialized" {
            assert!(!properties.contains_key("id"));
        } else {
            assert!(properties.contains_key("id"), "missing id for {method}");
            assert!(required.iter().any(|field| field == "id"));
        }
    }

    for variant in envelope_variants(bundle.get("ServerRequest").expect("server schema")) {
        let properties = variant["properties"].as_object().expect("properties");
        let required = variant["required"].as_array().expect("required");
        assert_eq!(properties["jsonrpc"]["const"], "2.0");
        assert!(properties.contains_key("id"));
        assert!(required.iter().any(|field| field == "jsonrpc"));
        assert!(required.iter().any(|field| field == "id"));
    }
}

#[test]
fn request_typescript_declares_json_rpc_envelopes() {
    let bundle = generate_app_server_typescript_bundle().expect("typescript bundle");
    let client = bundle.get("ClientRequest.ts").expect("client TypeScript");
    let server = bundle.get("ServerRequest.ts").expect("server TypeScript");
    assert!(client.contains("jsonrpc: \"2.0\""));
    assert!(client.contains("id: RequestId"));
    assert!(server.contains("jsonrpc: \"2.0\""));
    assert!(server.contains("id: RequestId"));
}