Merge pull request #20 from agntcy/fix/19-jsonrpc-agent-card-interop

fix: align jsonrpc and agent-card interop

Author: muscariello

a2a-client/src/agent_card.rs

@@ -43,3 +43,59 @@ impl AgentCardResolver {
             .map_err(|e| A2AError::internal(format!("failed to parse agent card: {e}")))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio::net::TcpListener;
+
+    async fn spawn_agent_card_server(body: &'static str) -> String {
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let mut buffer = [0_u8; 4096];
+            let _ = socket.read(&mut buffer).await;
+
+            let response = format!(
+                "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}",
+                body.len(),
+                body,
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        format!("http://{addr}")
+    }
+
+    #[tokio::test]
+    async fn test_resolve_accepts_null_skills() {
+        let server = spawn_agent_card_server(
+            r#"{
+                "name": "Test Agent",
+                "description": "A test agent",
+                "version": "1.0.0",
+                "supportedInterfaces": [
+                    {
+                        "url": "http://127.0.0.1:3000/jsonrpc",
+                        "protocolBinding": "JSONRPC",
+                        "protocolVersion": "1.0"
+                    }
+                ],
+                "capabilities": { "streaming": true },
+                "defaultInputModes": ["text/plain"],
+                "defaultOutputModes": ["text/plain"],
+                "skills": null
+            }"#,
+        )
+        .await;
+
+        let resolver = AgentCardResolver::new(None);
+        let card = resolver.resolve(&server).await.unwrap();
+
+        assert!(card.skills.is_empty());
+        assert_eq!(card.supported_interfaces[0].protocol_binding, "JSONRPC");
+    }
+}

a2a-client/src/middleware.rs

@@ -78,22 +78,28 @@ mod tests {
     async fn test_logging_interceptor_before() {
         let interceptor = LoggingInterceptor;
         let mut params = ServiceParams::new();
-        let result = interceptor.before("message.send", &mut params).await;
+        let result = interceptor
+            .before(a2a::jsonrpc::methods::SEND_MESSAGE, &mut params)
+            .await;
         assert!(result.is_ok());
     }
 
     #[tokio::test]
     async fn test_logging_interceptor_after_ok() {
         let interceptor = LoggingInterceptor;
-        let result = interceptor.after("message.send", &Ok(())).await;
+        let result = interceptor
+            .after(a2a::jsonrpc::methods::SEND_MESSAGE, &Ok(()))
+            .await;
         assert!(result.is_ok());
     }
 
     #[tokio::test]
     async fn test_logging_interceptor_after_err() {
         let interceptor = LoggingInterceptor;
         let err = Err(A2AError::internal("boom"));
-        let result = interceptor.after("message.send", &err).await;
+        let result = interceptor
+            .after(a2a::jsonrpc::methods::SEND_MESSAGE, &err)
+            .await;
         assert!(result.is_ok());
     }
 }

a2a-server/src/jsonrpc.rs

@@ -291,16 +291,31 @@ mod tests {
                 "parts": [{"text": "hello"}]
             }
         });
-        let resp = post_jsonrpc(app, "message.send", params).await;
+        let resp = post_jsonrpc(app, methods::SEND_MESSAGE, params).await;
         assert!(resp.error.is_none(), "unexpected error: {:?}", resp.error);
         assert!(resp.result.is_some());
     }
 
+    #[tokio::test]
+    async fn test_send_message_legacy_method_rejected() {
+        let app = make_app();
+        let params = serde_json::json!({
+            "message": {
+                "messageId": "m1",
+                "role": "ROLE_USER",
+                "parts": [{"text": "hello"}]
+            }
+        });
+        let resp = post_jsonrpc(app, "message.send", params).await;
+        assert!(resp.error.is_some(), "unexpected result: {:?}", resp.result);
+        assert_eq!(resp.error.unwrap().code, error_code::METHOD_NOT_FOUND);
+    }
+
     #[tokio::test]
     async fn test_get_task_not_found() {
         let app = make_app();
         let params = serde_json::json!({"id": "nonexistent"});
-        let resp = post_jsonrpc(app, "tasks.get", params).await;
+        let resp = post_jsonrpc(app, methods::GET_TASK, params).await;
         assert!(resp.error.is_some());
         assert_eq!(resp.error.unwrap().code, error_code::TASK_NOT_FOUND);
     }
@@ -326,7 +341,7 @@ mod tests {
         let rpc = serde_json::json!({
             "jsonrpc": "1.0",
             "id": 1,
-            "method": "message.send",
+            "method": methods::SEND_MESSAGE,
             "params": {}
         });
         let body = serde_json::to_string(&rpc).unwrap();
@@ -346,7 +361,7 @@ mod tests {
     async fn test_invalid_params() {
         let app = make_app();
         let params = serde_json::json!({"bogus": true});
-        let resp = post_jsonrpc(app, "message.send", params).await;
+        let resp = post_jsonrpc(app, methods::SEND_MESSAGE, params).await;
         assert!(resp.error.is_some());
         assert_eq!(resp.error.unwrap().code, error_code::PARSE_ERROR);
     }
@@ -355,15 +370,15 @@ mod tests {
     async fn test_list_tasks() {
         let app = make_app();
         let params = serde_json::json!({});
-        let resp = post_jsonrpc(app, "tasks.list", params).await;
+        let resp = post_jsonrpc(app, methods::LIST_TASKS, params).await;
         assert!(resp.result.is_some());
     }
 
     #[tokio::test]
     async fn test_cancel_task_not_found() {
         let app = make_app();
         let params = serde_json::json!({"id": "nonexistent"});
-        let resp = post_jsonrpc(app, "tasks.cancel", params).await;
+        let resp = post_jsonrpc(app, methods::CANCEL_TASK, params).await;
         assert!(resp.error.is_some());
     }
 
@@ -376,7 +391,7 @@ mod tests {
                 "url": "http://example.com/callback"
             }
         });
-        let resp = post_jsonrpc(app, "tasks.pushNotificationConfig.create", params).await;
+        let resp = post_jsonrpc(app, methods::CREATE_PUSH_CONFIG, params).await;
         // May fail since task doesn't exist, but method is dispatched
         assert!(resp.error.is_some() || resp.result.is_some());
     }
@@ -388,7 +403,7 @@ mod tests {
             "taskId": "t1",
             "id": "cfg1"
         });
-        let resp = post_jsonrpc(app, "tasks.pushNotificationConfig.get", params).await;
+        let resp = post_jsonrpc(app, methods::GET_PUSH_CONFIG, params).await;
         assert!(resp.error.is_some() || resp.result.is_some());
     }
 
@@ -398,7 +413,7 @@ mod tests {
         let params = serde_json::json!({
             "taskId": "t1"
         });
-        let resp = post_jsonrpc(app, "tasks.pushNotificationConfig.list", params).await;
+        let resp = post_jsonrpc(app, methods::LIST_PUSH_CONFIGS, params).await;
         assert!(resp.error.is_some() || resp.result.is_some());
     }
 
@@ -409,15 +424,15 @@ mod tests {
             "taskId": "t1",
             "id": "cfg1"
         });
-        let resp = post_jsonrpc(app, "tasks.pushNotificationConfig.delete", params).await;
+        let resp = post_jsonrpc(app, methods::DELETE_PUSH_CONFIG, params).await;
         assert!(resp.error.is_some() || resp.result.is_some());
     }
 
     #[tokio::test]
     async fn test_get_extended_agent_card() {
         let app = make_app();
         let params = serde_json::json!({});
-        let resp = post_jsonrpc(app, "agent.extendedCard.get", params).await;
+        let resp = post_jsonrpc(app, methods::GET_EXTENDED_AGENT_CARD, params).await;
         // DefaultRequestHandler returns NotSupported
         assert!(resp.error.is_some() || resp.result.is_some());
     }
@@ -432,7 +447,11 @@ mod tests {
                 "parts": [{"text": "hello"}]
             }
         });
-        let rpc = JsonRpcRequest::new(JsonRpcId::Number(1), "message.stream", Some(body));
+        let rpc = JsonRpcRequest::new(
+            JsonRpcId::Number(1),
+            methods::SEND_STREAMING_MESSAGE,
+            Some(body),
+        );
         let req = Request::builder()
             .uri("/")
             .method("POST")
@@ -450,7 +469,7 @@ mod tests {
         let app = make_app();
         let rpc = JsonRpcRequest::new(
             JsonRpcId::Number(1),
-            "tasks.subscribe",
+            methods::SUBSCRIBE_TO_TASK,
             Some(serde_json::json!({"id": "t1"})),
         );
         let req = Request::builder()
@@ -464,6 +483,35 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
+    #[tokio::test]
+    async fn test_streaming_send_message_legacy_method_rejected() {
+        let app = make_app();
+        let body = serde_json::json!({
+            "message": {
+                "messageId": "m1",
+                "role": "ROLE_USER",
+                "parts": [{"text": "hello"}]
+            }
+        });
+        let rpc = JsonRpcRequest::new(JsonRpcId::Number(1), "message.stream", Some(body));
+        let req = Request::builder()
+            .uri("/")
+            .method("POST")
+            .header("content-type", "application/json")
+            .header("accept", "text/event-stream")
+            .body(Body::from(serde_json::to_string(&rpc).unwrap()))
+            .unwrap();
+        let resp = app.oneshot(req).await.unwrap();
+        let body = resp.into_body().collect().await.unwrap().to_bytes();
+        let rpc_resp: JsonRpcResponse = serde_json::from_slice(&body).unwrap();
+        assert!(
+            rpc_resp.error.is_some(),
+            "unexpected result: {:?}",
+            rpc_resp.result
+        );
+        assert_eq!(rpc_resp.error.unwrap().code, error_code::METHOD_NOT_FOUND);
+    }
+
     #[tokio::test]
     async fn test_streaming_invalid_method() {
         let app = make_app();

a2a-server/src/middleware.rs

@@ -121,8 +121,8 @@ mod tests {
     #[test]
     fn test_call_context_new() {
         let params = ServiceParams::new();
-        let ctx = CallContext::new("message.send", params);
-        assert_eq!(ctx.method, "message.send");
+        let ctx = CallContext::new(a2a::jsonrpc::methods::SEND_MESSAGE, params);
+        assert_eq!(ctx.method, a2a::jsonrpc::methods::SEND_MESSAGE);
         assert!(ctx.tenant.is_none());
         assert!(ctx.user.is_none());
     }
@@ -166,23 +166,23 @@ mod tests {
     #[tokio::test]
     async fn test_logging_interceptor_before() {
         let interceptor = LoggingInterceptor;
-        let mut ctx = CallContext::new("message.send", ServiceParams::new());
+        let mut ctx = CallContext::new(a2a::jsonrpc::methods::SEND_MESSAGE, ServiceParams::new());
         let result = interceptor.before(&mut ctx, &Value::Null).await;
         assert!(result.is_ok());
     }
 
     #[tokio::test]
     async fn test_logging_interceptor_after_ok() {
         let interceptor = LoggingInterceptor;
-        let ctx = CallContext::new("message.send", ServiceParams::new());
+        let ctx = CallContext::new(a2a::jsonrpc::methods::SEND_MESSAGE, ServiceParams::new());
         let result = interceptor.after(&ctx, &Ok(Value::Null)).await;
         assert!(result.is_ok());
     }
 
     #[tokio::test]
     async fn test_logging_interceptor_after_err() {
         let interceptor = LoggingInterceptor;
-        let ctx = CallContext::new("message.send", ServiceParams::new());
+        let ctx = CallContext::new(a2a::jsonrpc::methods::SEND_MESSAGE, ServiceParams::new());
         let err: Result<Value, A2AError> = Err(A2AError::internal("boom"));
         let result = interceptor.after(&ctx, &err).await;
         assert!(result.is_ok());

a2a/src/agent_card.rs

@@ -1,6 +1,6 @@
 // Copyright AGNTCY Contributors (https://github.com/agntcy)
 // SPDX-License-Identifier: Apache-2.0
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
 
@@ -21,6 +21,7 @@ pub struct AgentCard {
     pub capabilities: AgentCapabilities,
     pub default_input_modes: Vec<String>,
     pub default_output_modes: Vec<String>,
+    #[serde(default, deserialize_with = "deserialize_vec_null_as_default")]
     pub skills: Vec<AgentSkill>,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -42,6 +43,14 @@ pub struct AgentCard {
     pub signatures: Option<Vec<AgentCardSignature>>,
 }
 
+fn deserialize_vec_null_as_default<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    Ok(Option::<Vec<T>>::deserialize(deserializer)?.unwrap_or_default())
+}
+
 // ---------------------------------------------------------------------------
 // AgentInterface
 // ---------------------------------------------------------------------------
@@ -577,4 +586,57 @@ mod tests {
         let back: AgentCard = serde_json::from_str(&json).unwrap();
         assert_eq!(card, back);
     }
+
+    #[test]
+    fn test_agent_card_deserializes_null_skills_as_empty() {
+        let card: AgentCard = serde_json::from_str(
+            r#"{
+                "name": "Test Agent",
+                "description": "A test agent",
+                "version": "1.0.0",
+                "supportedInterfaces": [
+                    {
+                        "url": "http://localhost:3000",
+                        "protocolBinding": "JSONRPC",
+                        "protocolVersion": "1.0"
+                    }
+                ],
+                "capabilities": {
+                    "streaming": true
+                },
+                "defaultInputModes": ["text/plain"],
+                "defaultOutputModes": ["text/plain"],
+                "skills": null
+            }"#,
+        )
+        .unwrap();
+
+        assert!(card.skills.is_empty());
+    }
+
+    #[test]
+    fn test_agent_card_deserializes_missing_skills_as_empty() {
+        let card: AgentCard = serde_json::from_str(
+            r#"{
+                "name": "Test Agent",
+                "description": "A test agent",
+                "version": "1.0.0",
+                "supportedInterfaces": [
+                    {
+                        "url": "http://localhost:3000",
+                        "protocolBinding": "JSONRPC",
+                        "protocolVersion": "1.0"
+                    }
+                ],
+                "capabilities": {
+                    "streaming": true
+                },
+                "defaultInputModes": ["text/plain"],
+                "defaultOutputModes": ["text/plain"]
+            }"#,
+        )
+        .unwrap();
+
+        assert!(card.skills.is_empty());
+    }
 }