substrate-a2a 0.3.7

A2A-shaped wire schema (Task, Message, Artifact, Part). Transport-agnostic; depends only on serde/uuid/thiserror.
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

use a2a::message::{Artifact, Message, MessageKind, MsgState, Part};
use a2a::task::{Task, TaskState};

#[test]
fn task_serde_round_trip() {
    let task = Task::new("team-1", "Write a PR", "agent-lead");
    let json = serde_json::to_string(&task).expect("serialize");
    let back: Task = serde_json::from_str(&json).expect("deserialize");
    assert_eq!(task, back);
}

#[test]
fn message_serde_round_trip() {
    let msg = Message::new(
        "team-1",
        "lead",
        "worker",
        MessageKind::Task,
        vec![Part::Text {
            text: "do the thing".to_string(),
        }],
    );
    let json = serde_json::to_string(&msg).expect("serialize");
    let back: Message = serde_json::from_str(&json).expect("deserialize");
    assert_eq!(msg, back);
}

#[test]
fn artifact_serde_round_trip() {
    let art = Artifact {
        kind: "diff".to_string(),
        content: "--- a\n+++ b".to_string(),
        name: Some("patch.diff".to_string()),
    };
    let json = serde_json::to_string(&art).expect("serialize");
    let back: Artifact = serde_json::from_str(&json).expect("deserialize");
    assert_eq!(art, back);
}

#[test]
fn task_state_submitted_to_working_is_legal() {
    assert!(TaskState::can_transition(
        TaskState::Submitted,
        TaskState::Working
    ));
    assert!(!TaskState::Working.is_terminal());
    assert!(TaskState::Completed.is_terminal());
}

#[test]
fn task_state_completed_to_working_is_illegal() {
    // Completed is terminal — no outgoing transitions
    assert!(!TaskState::can_transition(
        TaskState::Completed,
        TaskState::Working
    ));
}

#[test]
fn msg_state_variants_serialize() {
    let states = [MsgState::Unread, MsgState::Delivered, MsgState::Consumed];
    for s in states {
        let json = serde_json::to_string(&s).expect("serialize MsgState");
        let back: MsgState = serde_json::from_str(&json).expect("deserialize MsgState");
        assert_eq!(s, back);
    }
}

#[test]
fn part_file_round_trip() {
    let part = Part::File {
        uri: "file:///tmp/foo.diff".to_string(),
    };
    let json = serde_json::to_string(&part).expect("serialize Part::File");
    let back: Part = serde_json::from_str(&json).expect("deserialize Part::File");
    assert_eq!(part, back);
}

#[test]
fn part_data_round_trip() {
    let part = Part::Data {
        data: serde_json::json!({"key": "value", "num": 42}),
    };
    let json = serde_json::to_string(&part).expect("serialize Part::Data");
    let back: Part = serde_json::from_str(&json).expect("deserialize Part::Data");
    assert_eq!(part, back);
}