mika-a2a 0.3.1

A2A (Agent-to-Agent) protocol implementation for Mika
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use crate::types::TaskState;

/// Validates task state transitions according to the A2A protocol.
pub struct TaskStateMachine;

impl TaskStateMachine {
    /// Check if a state is terminal (no further transitions allowed).
    pub fn is_terminal(state: TaskState) -> bool {
        matches!(
            state,
            TaskState::Completed | TaskState::Failed | TaskState::Canceled | TaskState::Rejected
        )
    }

    /// Check if a transition from one state to another is valid.
    pub fn can_transition(from: TaskState, to: TaskState) -> bool {
        matches!(
            (from, to),
            // From Submitted
            (TaskState::Submitted, TaskState::Working)
                | (TaskState::Submitted, TaskState::Canceled)
                | (TaskState::Submitted, TaskState::Rejected)
                // From Working
                | (TaskState::Working, TaskState::Completed)
                | (TaskState::Working, TaskState::Failed)
                | (TaskState::Working, TaskState::Canceled)
                | (TaskState::Working, TaskState::InputRequired)
                | (TaskState::Working, TaskState::AuthRequired)
                // From InputRequired
                | (TaskState::InputRequired, TaskState::Working)
                | (TaskState::InputRequired, TaskState::Canceled)
                | (TaskState::InputRequired, TaskState::Failed)
                // From AuthRequired
                | (TaskState::AuthRequired, TaskState::Working)
                | (TaskState::AuthRequired, TaskState::Canceled)
                | (TaskState::AuthRequired, TaskState::Failed)
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_terminal_states() {
        assert!(TaskStateMachine::is_terminal(TaskState::Completed));
        assert!(TaskStateMachine::is_terminal(TaskState::Failed));
        assert!(TaskStateMachine::is_terminal(TaskState::Canceled));
        assert!(TaskStateMachine::is_terminal(TaskState::Rejected));
        assert!(!TaskStateMachine::is_terminal(TaskState::Submitted));
        assert!(!TaskStateMachine::is_terminal(TaskState::Working));
        assert!(!TaskStateMachine::is_terminal(TaskState::InputRequired));
        assert!(!TaskStateMachine::is_terminal(TaskState::AuthRequired));
        assert!(!TaskStateMachine::is_terminal(TaskState::Unknown));
    }

    #[test]
    fn test_valid_transitions() {
        // Submitted transitions
        assert!(TaskStateMachine::can_transition(
            TaskState::Submitted,
            TaskState::Working
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Submitted,
            TaskState::Canceled
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Submitted,
            TaskState::Rejected
        ));

        // Working transitions
        assert!(TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::Completed
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::Failed
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::Canceled
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::InputRequired
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::AuthRequired
        ));

        // InputRequired transitions
        assert!(TaskStateMachine::can_transition(
            TaskState::InputRequired,
            TaskState::Working
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::InputRequired,
            TaskState::Canceled
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::InputRequired,
            TaskState::Failed
        ));

        // AuthRequired transitions
        assert!(TaskStateMachine::can_transition(
            TaskState::AuthRequired,
            TaskState::Working
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::AuthRequired,
            TaskState::Canceled
        ));
        assert!(TaskStateMachine::can_transition(
            TaskState::AuthRequired,
            TaskState::Failed
        ));
    }

    #[test]
    fn test_invalid_transitions() {
        // Cannot transition from terminal states
        assert!(!TaskStateMachine::can_transition(
            TaskState::Completed,
            TaskState::Working
        ));
        assert!(!TaskStateMachine::can_transition(
            TaskState::Failed,
            TaskState::Working
        ));
        assert!(!TaskStateMachine::can_transition(
            TaskState::Canceled,
            TaskState::Working
        ));
        assert!(!TaskStateMachine::can_transition(
            TaskState::Rejected,
            TaskState::Working
        ));

        // Cannot skip states
        assert!(!TaskStateMachine::can_transition(
            TaskState::Submitted,
            TaskState::Completed
        ));
        assert!(!TaskStateMachine::can_transition(
            TaskState::Submitted,
            TaskState::InputRequired
        ));

        // Cannot go backward
        assert!(!TaskStateMachine::can_transition(
            TaskState::Working,
            TaskState::Submitted
        ));
    }
}