acp-runtime 0.1.2

Rust SDK for the Agent Communication Protocol (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

use std::collections::HashMap;

use acp_runtime::crypto;
use acp_runtime::messages::{Envelope, MessageClass};
use serde_json::{Map, Value};

#[test]
fn encrypt_sign_verify_and_decrypt_roundtrip() {
    let (sender_signing_private, sender_signing_public) = crypto::generate_ed25519_keypair();
    let (recipient_encryption_private, recipient_encryption_public) =
        crypto::generate_x25519_keypair();
    let envelope = Envelope::build(
        "agent:sender@demo",
        vec!["agent:recipient@demo".to_string()],
        MessageClass::Send,
        "ctx:test",
        300,
        Some("op:roundtrip".to_string()),
        Some("tenant.demo".to_string()),
        None,
        None,
        None,
    )
    .expect("envelope should be created");
    assert_eq!(envelope.tenant.as_deref(), Some("tenant.demo"));

    let mut payload = Map::new();
    payload.insert("type".to_string(), Value::String("demo".to_string()));
    payload.insert("sequence".to_string(), Value::Number(1.into()));

    let recipient_keys = HashMap::from([(
        "agent:recipient@demo".to_string(),
        recipient_encryption_public.clone(),
    )]);
    let mut protected = crypto::encrypt_for_recipients(&payload, &envelope, &recipient_keys)
        .expect("payload encryption should succeed");
    crypto::sign_protected_payload(
        &envelope,
        &mut protected,
        &sender_signing_private,
        "sig:test",
    )
    .expect("payload signature should succeed");

    assert!(crypto::verify_protected_payload_signature(
        &envelope,
        &protected,
        &sender_signing_public
    ));

    let decrypted = crypto::decrypt_for_recipient(
        &envelope,
        &protected,
        "agent:recipient@demo",
        &recipient_encryption_private,
    )
    .expect("recipient decryption should succeed");

    assert_eq!(
        decrypted.get("type").and_then(Value::as_str),
        Some("demo"),
        "decrypted payload should preserve type field"
    );
    assert_eq!(
        decrypted.get("sequence").and_then(Value::as_i64),
        Some(1),
        "decrypted payload should preserve numeric field"
    );
}