a2a-mcp 0.3.0

Bidirectional integration between A2A Protocol and Model Context Protocol (MCP)
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

//! Tests for a2a-mcp integration

#[cfg(test)]
mod message_converter_tests {
    use crate::message::MessageConverter;
    use a2a_rs::domain::message::{Message, MessagePart};
    use rmcp::{ClientJsonRpcMessage, ServerJsonRpcMessage};
    use serde_json::json;

    #[test]
    fn test_rmcp_to_a2a_request() {
        let converter = MessageConverter::new();
        
        let rmcp_request = ClientJsonRpcMessage {
            jsonrpc: "2.0".to_string(),
            id: Some(json!(1)),
            method: "test_method".to_string(),
            params: Some(json!({"key": "value"})),
        };
        
        let a2a_message = converter.rmcp_to_a2a_request(&rmcp_request).unwrap();
        
        assert_eq!(a2a_message.role, "user");
        assert_eq!(a2a_message.parts.len(), 2);
        
        // Check text part
        match &a2a_message.parts[0] {
            MessagePart::Text { text } => {
                assert!(text.contains("test_method"));
            },
            _ => panic!("Expected text part"),
        }
        
        // Check data part
        match &a2a_message.parts[1] {
            MessagePart::Data { data, .. } => {
                assert_eq!(data["key"], "value");
            },
            _ => panic!("Expected data part"),
        }
    }

    #[test]
    fn test_a2a_to_rmcp_response() {
        let converter = MessageConverter::new();
        
        let a2a_message = Message {
            role: "agent".to_string(),
            parts: vec![
                MessagePart::Text { text: "Test response".to_string() },
                MessagePart::Data { 
                    data: json!({"result": "success"}),
                    mime_type: Some("application/json".to_string()),
                },
            ],
        };
        
        let id = Some(json!(123));
        let rmcp_response = converter.a2a_to_rmcp_response(&a2a_message, id.clone()).unwrap();
        
        assert_eq!(rmcp_response.jsonrpc, "2.0");
        assert_eq!(rmcp_response.id, id);
        assert!(rmcp_response.error.is_none());
        
        // Data part should be prioritized over text
        assert_eq!(rmcp_response.result.unwrap()["result"], "success");
    }
}

#[cfg(test)]
mod adapter_tests {
    use crate::adapter::{ToolToAgentAdapter, AgentToToolAdapter};
    use rmcp::{Tool, ToolCall};
    use serde_json::json;

    #[test]
    fn test_tool_to_agent_adapter() {
        let tools = vec![
            Tool {
                name: "test_tool".to_string(),
                description: "A test tool".to_string(),
                parameters: None,
            },
        ];
        
        let adapter = ToolToAgentAdapter::new(
            tools, 
            "Test Agent".to_string(),
            "An agent for testing".to_string(),
        );
        
        let agent_card = adapter.generate_agent_card();
        
        assert_eq!(agent_card.name, "Test Agent");
        assert_eq!(agent_card.description, "An agent for testing");
        assert_eq!(agent_card.skills.len(), 1);
        assert_eq!(agent_card.skills[0].name, "test_tool");
    }

    #[test]
    fn test_tool_call_to_task() {
        let tools = vec![
            Tool {
                name: "test_tool".to_string(),
                description: "A test tool".to_string(),
                parameters: None,
            },
        ];
        
        let adapter = ToolToAgentAdapter::new(
            tools, 
            "Test Agent".to_string(),
            "An agent for testing".to_string(),
        );
        
        let tool_call = ToolCall {
            method: "test_tool".to_string(),
            params: json!({"input": "test_input"}),
        };
        
        let task = adapter.tool_call_to_task(&tool_call).unwrap();
        
        assert_eq!(task.status.state, a2a_rs::domain::task::TaskState::Submitted);
        assert_eq!(task.messages.len(), 1);
        assert_eq!(task.messages[0].role, "user");
    }
}