From d56e9926b7095abbcfd426711aa61a6a482c385f Mon Sep 17 00:00:00 2001 From: gulldan <5641375+gulldan@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:20:16 +0300 Subject: [PATCH 1/5] fix(client): report the HTTP status of a non-JSON-RPC error response The JSON-RPC transport never looked at the status of a response. An error that something in front of the agent answers itself (an authenticating proxy's 401, a gateway's 429 or 502) carries no JSON-RPC envelope, so the caller got "failed to parse JSON-RPC response" and could not tell a credential or rate-limit problem from a broken server. A streaming call answered that way without a content type was handed to the SSE parser and came back as an empty stream. A body that is not a JSON-RPC envelope is now reported with its status, as the REST transport already does ("HTTP 429 Too Many Requests: "); a JSON-RPC envelope is still decoded whatever the status, and a non-success status is never treated as a stream. Fixes: #404 Co-Authored-By: Claude Opus 5.5 Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com> --- a2a-client/src/jsonrpc.rs | 107 +++++++++++++++++++++++++++++++++----- 1 file changed, 93 insertions(+), 14 deletions(-) diff --git a/a2a-client/src/jsonrpc.rs b/a2a-client/src/jsonrpc.rs index 79887b9e..6d3cf3ae 100644 --- a/a2a-client/src/jsonrpc.rs +++ b/a2a-client/src/jsonrpc.rs @@ -35,6 +35,22 @@ fn parse_jsonrpc_error(err: JsonRpcError) -> A2AError { crate::a2a_error_from_details(err.code, err.message, details) } +/// Parses a JSON-RPC envelope. A body that is not one, sent with a non-success +/// status (an authenticating proxy's 401, a gateway's 429 or 502), is reported +/// with that status, as the REST transport reports it. +fn parse_jsonrpc_response( + status: reqwest::StatusCode, + body: &str, +) -> Result { + serde_json::from_str(body).map_err(|e| { + if status.is_success() { + A2AError::internal(format!("failed to parse JSON-RPC response: {e}")) + } else { + A2AError::internal(format!("HTTP {status}: {body}")) + } + }) +} + /// JSON-RPC transport implementation. /// /// Sends all requests as JSON-RPC 2.0 POSTs to a single endpoint. @@ -67,6 +83,7 @@ impl JsonRpcTransport { } let response = wire::send(&self.client, builder.json(&rpc_request)).await?; + let status = response.status(); // Read the body as text first so the raw bytes can be logged before // they become a typed value; one error message still covers both a @@ -74,8 +91,7 @@ impl JsonRpcTransport { let body = wire::response_text(response) .await .map_err(|e| A2AError::internal(format!("failed to parse JSON-RPC response: {e}")))?; - let rpc_response: JsonRpcResponse = serde_json::from_str(&body) - .map_err(|e| A2AError::internal(format!("failed to parse JSON-RPC response: {e}")))?; + let rpc_response = parse_jsonrpc_response(status, &body)?; if let Some(err) = rpc_response.error { return Err(parse_jsonrpc_error(err)); @@ -150,14 +166,16 @@ impl JsonRpcTransport { // in the envelope rather than via status code. Detect that case by // content type before handing the body to the SSE parser, which // would otherwise find no `data:` frames and yield an empty stream. - // A response with no content type is still treated as a stream: + // A success with no content type is still treated as a stream: // reading it to inspect it would hang on a stream that has not sent - // anything yet. - let is_event_stream = response - .headers() - .get(reqwest::header::CONTENT_TYPE) - .map(|v| v.as_bytes().starts_with(b"text/event-stream")) - .unwrap_or(true); + // anything yet. A non-success status is never a stream. + let status = response.status(); + let is_event_stream = status.is_success() + && response + .headers() + .get(reqwest::header::CONTENT_TYPE) + .map(|v| v.as_bytes().starts_with(b"text/event-stream")) + .unwrap_or(true); if is_event_stream { let stream = response.bytes_stream(); @@ -166,9 +184,7 @@ impl JsonRpcTransport { let body = wire::response_text(response).await.map_err(|e| { A2AError::internal(format!("failed to parse JSON-RPC response: {e}")) })?; - let rpc_response: JsonRpcResponse = serde_json::from_str(&body).map_err(|e| { - A2AError::internal(format!("failed to parse JSON-RPC response: {e}")) - })?; + let rpc_response = parse_jsonrpc_response(status, &body)?; match rpc_response.error { Some(err) => Err(parse_jsonrpc_error(err)), @@ -525,12 +541,12 @@ impl Transport for JsonRpcTransport { } let response = wire::send(&self.client, builder.json(&rpc_request)).await?; + let status = response.status(); let body = wire::response_text(response) .await .map_err(|e| A2AError::internal(format!("failed to parse JSON-RPC response: {e}")))?; - let rpc_response: JsonRpcResponse = serde_json::from_str(&body) - .map_err(|e| A2AError::internal(format!("failed to parse JSON-RPC response: {e}")))?; + let rpc_response = parse_jsonrpc_response(status, &body)?; if let Some(err) = rpc_response.error { return Err(parse_jsonrpc_error(err)); @@ -657,6 +673,25 @@ mod tests { format!("http://{addr}") } + /// Answers one request with `status` and a body that is not JSON-RPC, as an + /// authenticating proxy or a gateway in front of the agent does. + async fn spawn_http_error_server(status: &'static str, 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 _request = read_http_request(&mut socket).await; + let response = format!( + "HTTP/1.1 {status}\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{body}", + body.len(), + ); + socket.write_all(response.as_bytes()).await.unwrap(); + }); + + format!("http://{addr}") + } + async fn read_http_request(socket: &mut TcpStream) -> String { let mut buffer = Vec::new(); let mut chunk = [0_u8; 1024]; @@ -1502,6 +1537,50 @@ mod tests { assert!(error.message.contains("failed to parse JSON-RPC response")); } + #[tokio::test] + async fn test_http_error_without_jsonrpc_body_reports_the_status() { + let endpoint = spawn_http_error_server("429 Too Many Requests", "budget exceeded").await; + let transport = + JsonRpcTransport::new(crate::default_reqwest_client(None).unwrap(), endpoint); + + let error = transport + .get_task( + &ServiceParams::new(), + &GetTaskRequest { + id: "task-1".into(), + history_length: None, + tenant: None, + }, + ) + .await + .unwrap_err(); + + assert_eq!(error.code, error_code::INTERNAL_ERROR); + assert_eq!(error.message, "HTTP 429 Too Many Requests: budget exceeded"); + } + + #[tokio::test] + async fn test_streaming_http_error_reports_the_status_not_an_empty_stream() { + // No content type, so the status is the only thing marking it as no stream. + let endpoint = spawn_http_error_server("401 Unauthorized", "").await; + let transport = + JsonRpcTransport::new(crate::default_reqwest_client(None).unwrap(), endpoint); + + let req = SubscribeToTaskRequest { + id: "task-1".into(), + tenant: None, + }; + let error = match transport + .subscribe_to_task(&ServiceParams::new(), &req) + .await + { + Err(e) => e, + Ok(_) => panic!("expected error, got a stream"), + }; + + assert_eq!(error.message, "HTTP 401 Unauthorized: "); + } + #[tokio::test] async fn test_create_push_config_rejects_missing_result() { let response = json!({ From 70f0f45658eefc229e52011417c6b067e0fb420a Mon Sep 17 00:00:00 2001 From: gulldan <5641375+gulldan@users.noreply.github.com> Date: Sat, 31 Oct 2026 18:20:02 +0300 Subject: [PATCH 2/5] test(client): take the subscribe error without an unreachable arm The streaming test matched on the result and panicked in an `Ok` arm that a passing run never reaches, so that line stayed uncovered. Taking the error with `.err().expect()` keeps the assertion and needs no `Debug` on the stream. Co-Authored-By: Claude Opus 5.5 Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com> --- a2a-client/src/jsonrpc.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/a2a-client/src/jsonrpc.rs b/a2a-client/src/jsonrpc.rs index 6d3cf3ae..87ea8b0c 100644 --- a/a2a-client/src/jsonrpc.rs +++ b/a2a-client/src/jsonrpc.rs @@ -1570,13 +1570,11 @@ mod tests { id: "task-1".into(), tenant: None, }; - let error = match transport + let error = transport .subscribe_to_task(&ServiceParams::new(), &req) .await - { - Err(e) => e, - Ok(_) => panic!("expected error, got a stream"), - }; + .err() + .expect("expected error, got a stream"); assert_eq!(error.message, "HTTP 401 Unauthorized: "); } From 9e749f4c2c1c45607a753eeabce27dae8ac5e76d Mon Sep 17 00:00:00 2001 From: gulldan <5641375+gulldan@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:20:13 +0300 Subject: [PATCH 3/5] fix(a2a-pb): decode integral Value numbers as integers google.protobuf.Value carries every number as a double, and proto_value_to_json_value turned each one back into a JSON float, so an integer in a data part or in metadata reached the executor, and a client's decoded response, as 3600.0. serde then refuses it for an integer type ("invalid type: floating point `3600.0`, expected u32"). A whole number within +-2^53, where a double is exact, is now given back as an integer; other numbers stay floats. The round-trip tests that used floats to work around this now use integers, and a new protojson test decodes a JSON-RPC SendMessage whose data part holds an integer and deserializes it into u32. Fixes: #399 Co-Authored-By: Claude Opus 5.5 Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com> --- a2a-pb/src/pbconv.rs | 26 +++++++++++++++++--------- a2a-pb/tests/protojson.rs | 23 +++++++++++++++++++++++ 2 files changed, 40 insertions(+), 9 deletions(-) diff --git a/a2a-pb/src/pbconv.rs b/a2a-pb/src/pbconv.rs index 64e561ad..ef8840eb 100644 --- a/a2a-pb/src/pbconv.rs +++ b/a2a-pb/src/pbconv.rs @@ -64,9 +64,7 @@ pub fn proto_value_to_json_value(v: &prost_types::Value) -> Value { match &v.kind { Some(Kind::NullValue(_)) => Value::Null, Some(Kind::BoolValue(b)) => Value::Bool(*b), - Some(Kind::NumberValue(n)) => serde_json::Number::from_f64(*n) - .map(Value::Number) - .unwrap_or(Value::Null), + Some(Kind::NumberValue(n)) => json_number(*n).map(Value::Number).unwrap_or(Value::Null), Some(Kind::StringValue(s)) => Value::String(s.clone()), Some(Kind::ListValue(list)) => { Value::Array(list.values.iter().map(proto_value_to_json_value).collect()) @@ -83,6 +81,18 @@ pub fn proto_value_to_json_value(v: &prost_types::Value) -> Value { } } +/// `google.protobuf.Value` holds every number as a double, so an integer such +/// as `3600` arrives as `3600.0`. A whole number within ±2^53, where a double +/// is exact, is given back as an integer so it still deserializes into one. +fn json_number(n: f64) -> Option { + const MAX_EXACT_INTEGER: f64 = 9_007_199_254_740_992.0; + if n.fract() == 0.0 && n.abs() <= MAX_EXACT_INTEGER { + Some((n as i64).into()) + } else { + serde_json::Number::from_f64(n) + } +} + /// Lowest `seconds` a `google.protobuf.Timestamp` may carry: `0001-01-01T00:00:00Z`. const PROTO_TIMESTAMP_MIN_SECONDS: i64 = -62_135_596_800; /// Highest `seconds` a `google.protobuf.Timestamp` may carry: `9999-12-31T23:59:59Z`. @@ -1495,10 +1505,9 @@ mod tests { fn test_struct_roundtrip() { let mut map = HashMap::new(); map.insert("str".to_string(), Value::String("hello".to_string())); - map.insert( - "num".to_string(), - Value::Number(serde_json::Number::from_f64(42.0).unwrap()), - ); + map.insert("num".to_string(), serde_json::json!(42)); + map.insert("negative".to_string(), serde_json::json!(-7)); + map.insert("fraction".to_string(), serde_json::json!(4.5)); map.insert("bool".to_string(), Value::Bool(true)); map.insert("null".to_string(), Value::Null); let proto_s = to_proto_struct(&map); @@ -2166,8 +2175,7 @@ mod tests { #[test] fn test_part_data_roundtrip() { - // Use f64 numbers since proto Value stores all numbers as f64 - let data = serde_json::json!({"nested": [1.0, 2.0, 3.0]}); + let data = serde_json::json!({"nested": [1, 2, 3], "ratio": 0.5}); let part = Part { content: PartContent::Data(data), filename: None, diff --git a/a2a-pb/tests/protojson.rs b/a2a-pb/tests/protojson.rs index 160809e9..b91a901a 100644 --- a/a2a-pb/tests/protojson.rs +++ b/a2a-pb/tests/protojson.rs @@ -313,3 +313,26 @@ fn stream_response_protojson_roundtrip_serializes_oneof_payloads() { let roundtrip: StreamResponse = serde_json::from_value(json).unwrap(); assert_eq!(response, roundtrip); } + +/// `google.protobuf.Value` carries every number as a double, so an integer in +/// a data part has to come back out as an integer, not as `3600.0`. +#[test] +fn integers_in_data_parts_stay_integers() { + let request: a2a::SendMessageRequest = a2a_pb::protojson_conv::from_value(json!({ + "message": { + "messageId": "msg-1", + "role": "ROLE_USER", + "parts": [{"data": {"sinceSeconds": 3600, "ratio": 0.5}}] + } + })) + .unwrap(); + + let a2a::PartContent::Data(data) = &request.message.parts[0].content else { + panic!("expected a data part"); + }; + assert_eq!( + serde_json::from_value::(data["sinceSeconds"].clone()).unwrap(), + 3600 + ); + assert_eq!(data["ratio"], json!(0.5)); +} From 1997ab7d5d3e17d8d01bfbf1241576d5a4d0c2ec Mon Sep 17 00:00:00 2001 From: gulldan <5641375+gulldan@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:22:30 +0300 Subject: [PATCH 4/5] feat(server): bound the finished tasks InMemoryTaskStore keeps InMemoryTaskStore never removed a task, and TaskStore has no delete, so a long-running agent kept every task it ever served: 20,000 tasks with a 4 KiB artifact each held 192 MiB. InMemoryTaskStore::with_terminal_task_limit(n) keeps at most n tasks in a terminal state and purges the one that reached its terminal state earliest. Tasks that are not terminal are never purged, and a purged task reads as TaskNotFoundError, which A2A 3.3.2 allows for a task that was completed and purged. new() keeps every task, as before. With a limit of 1,000 the same run stays at about 20 MiB. Fixes: #401 Co-Authored-By: Claude Opus 5.5 Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com> --- a2a-server/src/task_store/inmemory.rs | 124 ++++++++++++++++++++++++-- 1 file changed, 116 insertions(+), 8 deletions(-) diff --git a/a2a-server/src/task_store/inmemory.rs b/a2a-server/src/task_store/inmemory.rs index 93878f4e..e8b7e270 100644 --- a/a2a-server/src/task_store/inmemory.rs +++ b/a2a-server/src/task_store/inmemory.rs @@ -3,7 +3,7 @@ // SPDX-License-Identifier: Apache-2.0 use a2a::*; use async_trait::async_trait; -use std::collections::HashMap; +use std::collections::{HashMap, VecDeque}; use tokio::sync::RwLock; use super::apply_history_length; @@ -15,17 +15,54 @@ struct StoredEntry { version: TaskVersion, } +#[derive(Default)] +struct Tasks { + entries: HashMap, + /// Terminal task ids, oldest first; tracked only under a limit. + terminal: VecDeque, +} + +impl Tasks { + /// Records that `id` reached a terminal state, then purges the tasks that + /// reached one earliest until at most `limit` remain. + fn retire(&mut self, id: &str, limit: Option) { + let Some(limit) = limit else { + return; + }; + self.terminal.push_back(id.to_string()); + while self.terminal.len() > limit { + if let Some(oldest) = self.terminal.pop_front() { + self.entries.remove(&oldest); + } + } + } +} + /// In-memory task store. Contents do not survive restarts. +/// +/// Keeps every task for the life of the process unless +/// [`Self::with_terminal_task_limit`] bounds how many finished ones it holds. pub struct InMemoryTaskStore { - tasks: RwLock>, + tasks: RwLock, + terminal_task_limit: Option, } impl InMemoryTaskStore { pub fn new() -> Self { InMemoryTaskStore { - tasks: RwLock::new(HashMap::new()), + tasks: RwLock::new(Tasks::default()), + terminal_task_limit: None, } } + + /// Keep at most `limit` tasks in a terminal state, purging the one that + /// reached its terminal state earliest first. A purged task is reported + /// as `TaskNotFoundError`, which §3.3.2 allows for a completed and purged + /// task. Tasks that are not terminal are never purged. + pub fn with_terminal_task_limit(mut self, limit: usize) -> Self { + self.terminal_task_limit = Some(limit); + self + } } impl Default for InMemoryTaskStore { @@ -38,17 +75,24 @@ impl Default for InMemoryTaskStore { impl TaskStore for InMemoryTaskStore { async fn create(&self, task: Task) -> Result { let mut store = self.tasks.write().await; - if store.contains_key(&task.id) { + if store.entries.contains_key(&task.id) { return Err(crate::sanitized_internal_error("task already exists")); } let id = task.id.clone(); - store.insert(id, StoredEntry { task, version: 1 }); + let terminal = task.status.state.is_terminal(); + store + .entries + .insert(id.clone(), StoredEntry { task, version: 1 }); + if terminal { + store.retire(&id, self.terminal_task_limit); + } Ok(1) } async fn update(&self, task: Task) -> Result { let mut store = self.tasks.write().await; let entry = store + .entries .get_mut(&task.id) .ok_or_else(|| A2AError::task_not_found(&task.id))?; // A terminal task's state is immutable. Re-applying the same @@ -61,9 +105,15 @@ impl TaskStore for InMemoryTaskStore { task.id, entry.task.status.state, task.status.state ))); } + let retired = !entry.task.status.state.is_terminal() && task.status.state.is_terminal(); entry.version += 1; entry.task = task; - Ok(entry.version) + let version = entry.version; + if retired { + let id = entry.task.id.clone(); + store.retire(&id, self.terminal_task_limit); + } + Ok(version) } async fn begin_cancel(&self, task_id: &str) -> Result { @@ -72,6 +122,7 @@ impl TaskStore for InMemoryTaskStore { // window. let mut store = self.tasks.write().await; let entry = store + .entries .get_mut(task_id) .ok_or_else(|| A2AError::task_not_found(task_id))?; if entry.task.status.state.is_terminal() { @@ -80,17 +131,20 @@ impl TaskStore for InMemoryTaskStore { entry.version += 1; entry.task.status.state = TaskState::Canceled; entry.task.status.timestamp = Some(chrono::Utc::now()); - Ok(entry.task.clone()) + let task = entry.task.clone(); + store.retire(task_id, self.terminal_task_limit); + Ok(task) } async fn get(&self, task_id: &str) -> Result, A2AError> { let store = self.tasks.read().await; - Ok(store.get(task_id).map(|e| e.task.clone())) + Ok(store.entries.get(task_id).map(|e| e.task.clone())) } async fn list(&self, req: &ListTasksRequest) -> Result { let store = self.tasks.read().await; let mut tasks: Vec = store + .entries .values() .filter(|entry| { // Filter by context_id if provided @@ -309,6 +363,60 @@ mod tests { assert_eq!(result.unwrap_err().code, error_code::TASK_NOT_FOUND); } + #[tokio::test] + async fn test_terminal_task_limit_purges_the_oldest_finished_task() { + let store = InMemoryTaskStore::new().with_terminal_task_limit(2); + store + .create(make_task("working", "c1", TaskState::Working)) + .await + .unwrap(); + for id in ["t1", "t2", "t3"] { + store + .create(make_task(id, "c1", TaskState::Working)) + .await + .unwrap(); + store + .update(make_task(id, "c1", TaskState::Completed)) + .await + .unwrap(); + } + // Re-applying a terminal state does not count the task twice. + store + .update(make_task("t3", "c1", TaskState::Completed)) + .await + .unwrap(); + + assert!(store.get("t1").await.unwrap().is_none()); + assert!(store.get("t2").await.unwrap().is_some()); + assert!(store.get("t3").await.unwrap().is_some()); + assert!(store.get("working").await.unwrap().is_some()); + + store.begin_cancel("working").await.unwrap(); + assert!(store.get("t2").await.unwrap().is_none()); + assert!(store.get("working").await.unwrap().is_some()); + + store + .create(make_task("t4", "c1", TaskState::Failed)) + .await + .unwrap(); + assert!(store.get("t3").await.unwrap().is_none()); + assert_eq!(store.tasks.read().await.entries.len(), 2); + } + + #[tokio::test] + async fn test_unlimited_store_keeps_every_finished_task() { + let store = InMemoryTaskStore::new(); + for i in 0..100 { + let id = format!("t{i}"); + store + .create(make_task(&id, "c1", TaskState::Completed)) + .await + .unwrap(); + } + assert_eq!(store.tasks.read().await.entries.len(), 100); + assert!(store.tasks.read().await.terminal.is_empty()); + } + #[tokio::test] async fn test_get_not_found() { let store = InMemoryTaskStore::new(); From 844bfb6a7a0762787f4d9f7b7c53ff6ef9ae8a65 Mon Sep 17 00:00:00 2001 From: gulldan <5641375+gulldan@users.noreply.github.com> Date: Sat, 31 Oct 2026 14:12:39 +0300 Subject: [PATCH 5/5] fix(server): enforce A2A-Version on the REST and gRPC bindings Only the JSON-RPC binding read A2A-Version: HTTP+JSON and gRPC served a request with `A2A-Version: 99.0`, or with no version at all, as a 1.0 request, although 3.6.2 requires every interface to answer VersionNotSupportedError and to read an empty value as 0.3. The JSON-RPC check moves unchanged to middleware::check_a2a_version. rest_router runs it ahead of every route and, when the header is absent, reads the A2A-Version query parameter that 3.6.1 allows instead; GrpcHandler runs it on the metadata of every method. Both answer with the existing VERSION_NOT_SUPPORTED mapping (400 / FAILED_PRECONDITION). Tests that call the transports directly now send the version, as the JSON-RPC ones already do. Fixes: #410 Co-Authored-By: Claude Opus 5.5 Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com> --- a2a-grpc/src/server.rs | 20 +++++ a2a-grpc/tests/e2e.rs | 69 +++++++++++++---- a2a-server/src/jsonrpc.rs | 29 +------ a2a-server/src/middleware.rs | 30 +++++++ a2a-server/src/rest.rs | 129 ++++++++++++++++++++++++++++++- examples/tests/transports_e2e.rs | 74 +++++++++--------- 6 files changed, 266 insertions(+), 85 deletions(-) diff --git a/a2a-grpc/src/server.rs b/a2a-grpc/src/server.rs index 1bb8b2ab..7a1bb721 100644 --- a/a2a-grpc/src/server.rs +++ b/a2a-grpc/src/server.rs @@ -52,6 +52,15 @@ fn extract_service_params( params } +/// §3.6.2 for every gRPC method, on the `A2A-Version` read from metadata +/// (§10.2) -- the same check the HTTP bindings apply. +#[allow(clippy::result_large_err)] +fn validate_protocol_version( + params: &a2a_server::middleware::ServiceParams, +) -> Result<(), tonic::Status> { + a2a_server::middleware::check_a2a_version(params).map_err(|error| a2a_error_to_status(&error)) +} + #[allow(clippy::result_large_err)] fn map_proto_stream_item( item: Result, @@ -69,6 +78,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_send_message_request(request.get_ref()); let result = self .handler @@ -87,6 +97,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_send_message_request(request.get_ref()); let stream = self .handler @@ -102,6 +113,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_get_task_request(request.get_ref()); let result = self .handler @@ -116,6 +128,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_list_tasks_request(request.get_ref()); let result = self .handler @@ -132,6 +145,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_cancel_task_request(request.get_ref()); let result = self .handler @@ -148,6 +162,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_subscribe_to_task_request(request.get_ref()); let stream = self .handler @@ -163,6 +178,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_create_task_push_notification_config_request(request.get_ref()); let result = self @@ -180,6 +196,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_get_task_push_notification_config_request(request.get_ref()); let result = self @@ -198,6 +215,7 @@ impl A2aService for GrpcHandler { ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_list_task_push_notification_configs_request(request.get_ref()); let result = self @@ -215,6 +233,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_get_extended_agent_card_request(request.get_ref()); let result = self .handler @@ -229,6 +248,7 @@ impl A2aService for GrpcHandler { request: tonic::Request, ) -> Result, tonic::Status> { let params = extract_service_params(request.metadata()); + validate_protocol_version(¶ms)?; let native_req = pbconv::from_proto_delete_task_push_notification_config_request(request.get_ref()); self.handler diff --git a/a2a-grpc/tests/e2e.rs b/a2a-grpc/tests/e2e.rs index 5c27f308..8b2f9631 100644 --- a/a2a-grpc/tests/e2e.rs +++ b/a2a-grpc/tests/e2e.rs @@ -335,6 +335,12 @@ fn endpoint_without_scheme(endpoint: &str) -> String { .unwrap_or_else(|| endpoint.to_string()) } +/// A2A-Version a real client sends (§3.6.1): the server rejects a request +/// without one (§3.6.2). +fn versioned_params() -> ServiceParams { + ServiceParams::from([(SVC_PARAM_VERSION.to_string(), vec![VERSION.to_string()])]) +} + fn send_message_request() -> SendMessageRequest { SendMessageRequest { message: sample_message(Role::User, "hello"), @@ -350,13 +356,13 @@ async fn grpc_transport_end_to_end() { let transport = GrpcTransport::connect(endpoint).await.unwrap(); let send_resp = transport - .send_message(&ServiceParams::new(), &send_message_request()) + .send_message(&versioned_params(), &send_message_request()) .await; assert!(matches!(send_resp.unwrap(), SendMessageResponse::Task(_))); let task = transport .get_task( - &ServiceParams::new(), + &versioned_params(), &GetTaskRequest { id: "task-1".to_string(), history_length: Some(1), @@ -369,7 +375,7 @@ async fn grpc_transport_end_to_end() { let list = transport .list_tasks( - &ServiceParams::new(), + &versioned_params(), &ListTasksRequest { context_id: Some("ctx-1".to_string()), status: Some(TaskState::Completed), @@ -387,7 +393,7 @@ async fn grpc_transport_end_to_end() { let canceled = transport .cancel_task( - &ServiceParams::new(), + &versioned_params(), &CancelTaskRequest { id: "task-1".to_string(), metadata: None, @@ -399,14 +405,14 @@ async fn grpc_transport_end_to_end() { assert_eq!(canceled.status.state, TaskState::Canceled); let created = transport - .create_push_config(&ServiceParams::new(), &sample_push_config("cfg-1")) + .create_push_config(&versioned_params(), &sample_push_config("cfg-1")) .await .unwrap(); assert_eq!(created.id.as_deref(), Some("cfg-1")); let fetched = transport .get_push_config( - &ServiceParams::new(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -419,7 +425,7 @@ async fn grpc_transport_end_to_end() { let configs = transport .list_push_configs( - &ServiceParams::new(), + &versioned_params(), &ListTaskPushNotificationConfigsRequest { task_id: "task-1".to_string(), page_size: Some(10), @@ -433,7 +439,7 @@ async fn grpc_transport_end_to_end() { transport .delete_push_config( - &ServiceParams::new(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -445,7 +451,7 @@ async fn grpc_transport_end_to_end() { let card = transport .get_extended_agent_card( - &ServiceParams::new(), + &versioned_params(), &GetExtendedAgentCardRequest { tenant: None }, ) .await @@ -462,7 +468,7 @@ async fn grpc_transport_streaming_and_error_paths() { let transport = GrpcTransport::connect(endpoint.clone()).await.unwrap(); let stream = transport - .send_streaming_message(&ServiceParams::new(), &send_message_request()) + .send_streaming_message(&versioned_params(), &send_message_request()) .await .unwrap(); let events: Vec<_> = stream.collect().await; @@ -474,7 +480,7 @@ async fn grpc_transport_streaming_and_error_paths() { let subscribe_stream = transport .subscribe_to_task( - &ServiceParams::new(), + &versioned_params(), &SubscribeToTaskRequest { id: "task-1".to_string(), tenant: None, @@ -487,7 +493,7 @@ async fn grpc_transport_streaming_and_error_paths() { let err = transport .get_task( - &ServiceParams::new(), + &versioned_params(), &GetTaskRequest { id: "missing".to_string(), history_length: None, @@ -500,7 +506,7 @@ async fn grpc_transport_streaming_and_error_paths() { let err = transport .delete_push_config( - &ServiceParams::new(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "missing".to_string(), @@ -533,7 +539,7 @@ async fn grpc_transport_accepts_bare_host_port_endpoints() { let transport = GrpcTransport::connect(bare_endpoint.clone()).await.unwrap(); let task = transport .get_task( - &ServiceParams::new(), + &versioned_params(), &GetTaskRequest { id: "task-1".to_string(), history_length: Some(1), @@ -553,7 +559,7 @@ async fn grpc_transport_accepts_bare_host_port_endpoints() { .await .unwrap(); let response = transport - .send_message(&ServiceParams::new(), &send_message_request()) + .send_message(&versioned_params(), &send_message_request()) .await .unwrap(); assert!(matches!(response, SendMessageResponse::Task(_))); @@ -569,7 +575,7 @@ async fn grpc_transport_treats_zero_page_size_as_unset() { let sent = transport .send_message( - &ServiceParams::new(), + &versioned_params(), &SendMessageRequest { message: Message::new(Role::User, vec![Part::text("hello")]), configuration: None, @@ -587,7 +593,7 @@ async fn grpc_transport_treats_zero_page_size_as_unset() { let listed = transport .list_tasks( - &ServiceParams::new(), + &versioned_params(), &ListTasksRequest { context_id: Some(task.context_id.clone()), status: None, @@ -609,3 +615,32 @@ async fn grpc_transport_treats_zero_page_size_as_unset() { transport.destroy().await.unwrap(); handle.abort(); } + +#[tokio::test] +async fn grpc_transport_rejects_unsupported_a2a_version() { + let (endpoint, handle) = spawn_grpc_server().await; + let transport = GrpcTransport::connect(endpoint).await.unwrap(); + + // §3.6.2: 99.0 is unsupported, and an absent version is "0.3". + let unsupported = + ServiceParams::from([(SVC_PARAM_VERSION.to_string(), vec!["99.0".to_string()])]); + for params in [unsupported, ServiceParams::new()] { + let err = transport + .send_message(¶ms, &send_message_request()) + .await + .unwrap_err(); + assert_eq!(err.code, error_code::VERSION_NOT_SUPPORTED, "{params:?}"); + + let err = match transport + .send_streaming_message(¶ms, &send_message_request()) + .await + { + Ok(_) => panic!("streaming accepted {params:?}"), + Err(err) => err, + }; + assert_eq!(err.code, error_code::VERSION_NOT_SUPPORTED, "{params:?}"); + } + + transport.destroy().await.unwrap(); + handle.abort(); +} diff --git a/a2a-server/src/jsonrpc.rs b/a2a-server/src/jsonrpc.rs index 0272c68c..87222cbb 100644 --- a/a2a-server/src/jsonrpc.rs +++ b/a2a-server/src/jsonrpc.rs @@ -16,7 +16,7 @@ use futures::{StreamExt, stream::BoxStream}; use serde_json::Value; use crate::handler::RequestHandler; -use crate::middleware::{ServiceParams, extract_service_params}; +use crate::middleware::{ServiceParams, check_a2a_version, extract_service_params}; use crate::sse; /// Shared state for the JSON-RPC handler. @@ -287,33 +287,6 @@ fn invalid_params(e: impl std::fmt::Display) -> A2AError { A2AError::invalid_params(format!("invalid params: {e}")) } -/// The major version this build implements (§3.6.2). Minor is accepted -/// unconditionally since nothing here branches on it. -const SUPPORTED_MAJOR_VERSION: u32 = 1; - -/// Mirrors a2acli's own `parse_protocol_version`: tolerant of a bare major, -/// extra trailing components, and surrounding whitespace. -fn parse_major_version(value: &str) -> Option { - value.trim().split('.').next()?.parse().ok() -} - -/// §3.6.2: reject a request whose `A2A-Version` header names an -/// unsupported major version. §3.6.1/§3.6.2 both require an absent header -/// to be interpreted as "0.3", not as "whatever this interface happens to -/// serve" -- so it's rejected here exactly like any other unsupported -/// version, rather than silently processed as this build's version. -fn check_a2a_version(params: &ServiceParams) -> Result<(), A2AError> { - let requested = params - .get("a2a-version") - .and_then(|v| v.first()) - .map(String::as_str) - .unwrap_or("0.3"); - match parse_major_version(requested) { - Some(SUPPORTED_MAJOR_VERSION) => Ok(()), - _ => Err(A2AError::version_not_supported(requested)), - } -} - #[cfg(test)] mod tests { use super::*; diff --git a/a2a-server/src/middleware.rs b/a2a-server/src/middleware.rs index 51435824..d328f10e 100644 --- a/a2a-server/src/middleware.rs +++ b/a2a-server/src/middleware.rs @@ -10,6 +10,36 @@ use std::collections::HashMap; /// Service parameters — metadata from HTTP headers or gRPC metadata. pub type ServiceParams = HashMap>; +/// The major version this build implements (§3.6.2). Minor is accepted +/// unconditionally since nothing here branches on it. +const SUPPORTED_MAJOR_VERSION: u32 = 1; + +/// Mirrors a2acli's own `parse_protocol_version`: tolerant of a bare major, +/// extra trailing components, and surrounding whitespace. +fn parse_major_version(value: &str) -> Option { + value.trim().split('.').next()?.parse().ok() +} + +/// §3.6.2: reject a request whose `A2A-Version` service parameter names an +/// unsupported major version. §3.6.1/§3.6.2 both require an absent value +/// to be interpreted as "0.3", not as "whatever this interface happens to +/// serve" -- so it's rejected here exactly like any other unsupported +/// version, rather than silently processed as this build's version. +/// +/// Every protocol binding calls this before dispatching a request, since +/// §3.6.2 applies to each interface the agent exposes. +pub fn check_a2a_version(params: &ServiceParams) -> Result<(), A2AError> { + let requested = params + .get("a2a-version") + .and_then(|v| v.first()) + .map(String::as_str) + .unwrap_or("0.3"); + match parse_major_version(requested) { + Some(SUPPORTED_MAJOR_VERSION) => Ok(()), + _ => Err(A2AError::version_not_supported(requested)), + } +} + /// Build [`ServiceParams`] from an axum [`HeaderMap`]. /// /// Header names are normalized to lowercase (axum does this for us), values diff --git a/a2a-server/src/rest.rs b/a2a-server/src/rest.rs index 6303ab10..7363a948 100644 --- a/a2a-server/src/rest.rs +++ b/a2a-server/src/rest.rs @@ -7,9 +7,10 @@ use a2a::*; use a2a_pb::protojson_conv::{self, ProtoJsonPayload}; use axum::{ Json, - extract::{Path, Query, State}, + extract::{Path, Query, Request, State}, http::{HeaderMap, HeaderValue, StatusCode, header}, - response::IntoResponse, + middleware::Next, + response::{IntoResponse, Response}, }; use chrono::{DateTime, Utc}; use futures::{StreamExt, stream::BoxStream}; @@ -18,7 +19,7 @@ use serde_json::Value; use std::collections::HashMap; use crate::handler::RequestHandler; -use crate::middleware::{ServiceParams, extract_service_params}; +use crate::middleware::{ServiceParams, check_a2a_version, extract_service_params}; use crate::sse; const REST_SEND_MESSAGE_PATH: &str = "/message:send"; @@ -116,12 +117,36 @@ pub fn rest_router(handler: Arc) -> axum::Router { REST_EXTENDED_AGENT_CARD_LEGACY_PATH, axum::routing::get(handle_get_extended_agent_card::), ) + .route_layer(axum::middleware::from_fn(validate_protocol_version)) .layer(axum::extract::DefaultBodyLimit::max( crate::jsonrpc::MAX_REQUEST_BODY_BYTES, )) .with_state(state) } +/// §3.6.2 for every REST operation, ahead of any handler. §3.6.1 lets a +/// client send `A2A-Version` as a query parameter instead of a header, so +/// the query form is honored when the header is absent. +async fn validate_protocol_version(request: Request, next: Next) -> Response { + let mut params = extract_service_params(request.headers()); + if !params.contains_key("a2a-version") { + let from_query = Query::>::try_from_uri(request.uri()) + .ok() + .and_then(|Query(query)| { + query + .into_iter() + .find(|(name, _)| name.eq_ignore_ascii_case(SVC_PARAM_VERSION)) + }); + if let Some((_, version)) = from_query { + params.insert("a2a-version".to_owned(), vec![version]); + } + } + match check_a2a_version(¶ms) { + Ok(()) => next.run(request).await, + Err(error) => rest_error_response(error), + } +} + async fn handle_send_message( State(state): State>, headers: HeaderMap, @@ -616,6 +641,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -638,6 +664,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -681,6 +708,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_LEGACY_PATH) .method("POST") .header("content-type", "application/json") @@ -694,6 +722,7 @@ mod tests { async fn test_get_task_not_found() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/nonexistent") .method("GET") .body(Body::empty()) @@ -706,6 +735,7 @@ mod tests { async fn test_list_tasks_empty() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks") .method("GET") .body(Body::empty()) @@ -723,6 +753,7 @@ mod tests { async fn test_cancel_task_not_found() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/nonexistent:cancel") .method("POST") .header("content-type", "application/json") @@ -739,6 +770,7 @@ mod tests { "url": "http://example.com/callback" }); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -756,6 +788,7 @@ mod tests { "url": "http://example.com/callback" }); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -779,6 +812,7 @@ mod tests { "url": "http://example.com/callback" }); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -801,6 +835,7 @@ mod tests { "url": "http://example.com/callback" }); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -814,6 +849,7 @@ mod tests { async fn test_get_extended_agent_card() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_EXTENDED_AGENT_CARD_PATH) .method("GET") .body(Body::empty()) @@ -1003,6 +1039,7 @@ mod tests { async fn test_subscribe_to_task_not_found() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/nonexistent:subscribe") .method("GET") .body(Body::empty()) @@ -1022,6 +1059,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_STREAM_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -1036,6 +1074,7 @@ mod tests { async fn test_get_push_config_not_found() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs/cfg1") .method("GET") .body(Body::empty()) @@ -1049,6 +1088,7 @@ mod tests { async fn test_list_push_configs() { let app = make_push_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("GET") .body(Body::empty()) @@ -1065,6 +1105,7 @@ mod tests { async fn test_delete_push_config() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs/cfg1") .method("DELETE") .body(Body::empty()) @@ -1081,6 +1122,7 @@ mod tests { "url": "http://example.com/callback" }); let create_req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -1090,6 +1132,7 @@ mod tests { assert_eq!(create_resp.status(), StatusCode::OK); let delete_req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs/cfg1") .method("DELETE") .body(Body::empty()) @@ -1098,6 +1141,7 @@ mod tests { assert_eq!(delete_resp.status(), StatusCode::OK); let list_req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("GET") .body(Body::empty()) @@ -1114,6 +1158,7 @@ mod tests { async fn test_list_tasks_with_query_params() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks?contextId=c1&pageSize=5&pageToken=0&historyLength=3&includeArtifacts=true&statusTimestampAfter=2025-01-01T00:00:00Z") .method("GET") .body(Body::empty()) @@ -1126,6 +1171,7 @@ mod tests { async fn test_list_tasks_invalid_status_returns_bad_request() { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks?status=invalid") .method("GET") .body(Body::empty()) @@ -1150,6 +1196,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -1181,6 +1228,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_STREAM_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -1205,6 +1253,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/some-id") .method("GET") .header("authorization", "Bearer get-task-token") @@ -1226,6 +1275,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks") .method("GET") .header("authorization", "Bearer list-tasks-token") @@ -1245,6 +1295,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/some-id:cancel") .method("POST") .header("authorization", "Bearer cancel-token") @@ -1265,6 +1316,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/some-id/cancel") .method("POST") .header("authorization", "Bearer cancel-legacy-token") @@ -1288,6 +1340,7 @@ mod tests { "url": "http://example.com/callback" }); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("POST") .header("content-type", "application/json") @@ -1308,6 +1361,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs") .method("GET") .header("authorization", "Bearer push-list-token") @@ -1327,6 +1381,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs/cfg1") .method("GET") .header("authorization", "Bearer push-get-token") @@ -1346,6 +1401,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/t1/pushNotificationConfigs/cfg1") .method("DELETE") .header("authorization", "Bearer push-delete-token") @@ -1365,6 +1421,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_EXTENDED_AGENT_CARD_PATH) .method("GET") .header("authorization", "Bearer card-token") @@ -1384,6 +1441,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/some-id:subscribe") .method("GET") .header("authorization", "Bearer subscribe-token") @@ -1405,6 +1463,7 @@ mod tests { let (handler, captured) = CapturingHandler::new(); let app = rest_router(handler); let req = Request::builder() + .header("a2a-version", "1.0") .uri("/tasks/some-id/subscribe") .method("GET") .header("authorization", "Bearer subscribe-legacy-token") @@ -1433,6 +1492,7 @@ mod tests { } }); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -1446,6 +1506,7 @@ mod tests { let app = make_app(); let req = Request::builder() + .header("a2a-version", "1.0") .uri(format!("/tasks/{}?historyLength=5", task_id)) .method("GET") .body(Body::empty()) @@ -1463,6 +1524,7 @@ mod tests { let app = make_app(); let oversized = Body::from("x".repeat(crate::jsonrpc::MAX_REQUEST_BODY_BYTES + 1)); let req = Request::builder() + .header("a2a-version", "1.0") .uri(REST_SEND_MESSAGE_PATH) .method("POST") .header("content-type", "application/json") @@ -1472,4 +1534,65 @@ mod tests { let resp = app.oneshot(req).await.unwrap(); assert_eq!(resp.status(), StatusCode::PAYLOAD_TOO_LARGE); } + + async fn send_message_with_version(uri: &str, version: Option<&str>) -> Response { + let body = serde_json::json!({ + "message": {"messageId": "m1", "role": "ROLE_USER", "parts": [{"text": "hi"}]} + }); + let mut req = Request::builder() + .uri(uri) + .method("POST") + .header("content-type", "application/json"); + if let Some(version) = version { + req = req.header("a2a-version", version); + } + let req = req.body(Body::from(body.to_string())).unwrap(); + make_app().oneshot(req).await.unwrap() + } + + async fn assert_version_not_supported(resp: Response) { + assert_eq!(resp.status(), StatusCode::BAD_REQUEST); + let body = resp.into_body().collect().await.unwrap().to_bytes(); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["error"]["status"], "FAILED_PRECONDITION", + "{payload}" + ); + assert_eq!( + payload["error"]["details"][0]["reason"], "VERSION_NOT_SUPPORTED", + "{payload}" + ); + } + + #[tokio::test] + async fn test_unsupported_a2a_version_is_rejected() { + // §3.6.2, §6.4: same rejection as JSON-RPC, in REST's error shape. + let resp = send_message_with_version(REST_SEND_MESSAGE_PATH, Some("99.0")).await; + assert_version_not_supported(resp).await; + } + + #[tokio::test] + async fn test_missing_a2a_version_is_rejected() { + // §3.6.2: an absent A2A-Version is "0.3", which this server does not + // implement -- on every route, not only SendMessage. + let resp = send_message_with_version(REST_SEND_MESSAGE_PATH, None).await; + assert_version_not_supported(resp).await; + + let req = Request::builder() + .uri("/tasks/t1") + .body(Body::empty()) + .unwrap(); + assert_version_not_supported(make_app().oneshot(req).await.unwrap()).await; + } + + #[tokio::test] + async fn test_a2a_version_query_parameter_is_accepted() { + // §3.6.1: a client MAY send the version as a request parameter. + let uri = format!("{REST_SEND_MESSAGE_PATH}?A2A-Version=1.0"); + let resp = send_message_with_version(&uri, None).await; + assert_eq!(resp.status(), StatusCode::OK); + + let uri = format!("{REST_SEND_MESSAGE_PATH}?A2A-Version=99.0"); + assert_version_not_supported(send_message_with_version(&uri, None).await).await; + } } diff --git a/examples/tests/transports_e2e.rs b/examples/tests/transports_e2e.rs index bd019c55..92f4e34f 100644 --- a/examples/tests/transports_e2e.rs +++ b/examples/tests/transports_e2e.rs @@ -431,9 +431,9 @@ async fn recv_push(receiver: &mut mpsc::UnboundedReceiver) -> Capt .unwrap() } -/// A2A-Version header a real client sends. Only JSON-RPC checks it -/// (§3.6.2); the REST tests use bare `ServiceParams::new()`. -fn jsonrpc_service_params() -> ServiceParams { +/// A2A-Version header a real client sends (§3.6.1); every binding rejects +/// a request without one (§3.6.2). +fn versioned_params() -> ServiceParams { let mut params = ServiceParams::new(); params.insert(SVC_PARAM_VERSION.to_string(), vec![VERSION.to_string()]); params @@ -454,13 +454,13 @@ async fn rest_transport_end_to_end() { let transport = RestTransport::new(Client::new(), format!("{base_url}/rest")); let send_resp = transport - .send_message(&ServiceParams::new(), &send_message_request()) + .send_message(&versioned_params(), &send_message_request()) .await; assert!(matches!(send_resp.unwrap(), SendMessageResponse::Task(_))); let task = transport .get_task( - &ServiceParams::new(), + &versioned_params(), &GetTaskRequest { id: "task-1".to_string(), history_length: Some(2), @@ -473,7 +473,7 @@ async fn rest_transport_end_to_end() { let not_found = transport .get_task( - &ServiceParams::new(), + &versioned_params(), &GetTaskRequest { id: "missing".to_string(), history_length: None, @@ -486,7 +486,7 @@ async fn rest_transport_end_to_end() { let list = transport .list_tasks( - &ServiceParams::new(), + &versioned_params(), &ListTasksRequest { context_id: Some("ctx-1".to_string()), status: Some(TaskState::Completed), @@ -504,7 +504,7 @@ async fn rest_transport_end_to_end() { let canceled = transport .cancel_task( - &ServiceParams::new(), + &versioned_params(), &CancelTaskRequest { id: "task-1".to_string(), metadata: None, @@ -517,7 +517,7 @@ async fn rest_transport_end_to_end() { let cancel_missing = transport .cancel_task( - &ServiceParams::new(), + &versioned_params(), &CancelTaskRequest { id: "missing".to_string(), metadata: None, @@ -530,7 +530,7 @@ async fn rest_transport_end_to_end() { let subscribed = transport .subscribe_to_task( - &ServiceParams::new(), + &versioned_params(), &SubscribeToTaskRequest { id: "task-1".to_string(), tenant: None, @@ -542,14 +542,14 @@ async fn rest_transport_end_to_end() { assert_eq!(events.len(), 1); let created = transport - .create_push_config(&ServiceParams::new(), &sample_push_config("cfg-1")) + .create_push_config(&versioned_params(), &sample_push_config("cfg-1")) .await .unwrap(); assert_eq!(created.task_id, "task-1"); let created_missing = transport .create_push_config( - &ServiceParams::new(), + &versioned_params(), &TaskPushNotificationConfig { task_id: "missing".to_string(), ..sample_push_config("cfg-1") @@ -561,7 +561,7 @@ async fn rest_transport_end_to_end() { let fetched = transport .get_push_config( - &ServiceParams::new(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -574,7 +574,7 @@ async fn rest_transport_end_to_end() { let fetched_missing = transport .get_push_config( - &ServiceParams::new(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "missing".to_string(), @@ -587,7 +587,7 @@ async fn rest_transport_end_to_end() { let configs = transport .list_push_configs( - &ServiceParams::new(), + &versioned_params(), &ListTaskPushNotificationConfigsRequest { task_id: "task-1".to_string(), page_size: Some(5), @@ -601,7 +601,7 @@ async fn rest_transport_end_to_end() { transport .delete_push_config( - &ServiceParams::new(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -613,7 +613,7 @@ async fn rest_transport_end_to_end() { let delete_missing = transport .delete_push_config( - &ServiceParams::new(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "missing".to_string(), @@ -645,12 +645,12 @@ async fn jsonrpc_transport_end_to_end() { let transport = JsonRpcTransport::new(Client::new(), format!("{base_url}/rpc")); let send_resp = transport - .send_message(&jsonrpc_service_params(), &send_message_request()) + .send_message(&versioned_params(), &send_message_request()) .await; assert!(matches!(send_resp.unwrap(), SendMessageResponse::Task(_))); let stream = transport - .send_streaming_message(&jsonrpc_service_params(), &send_message_request()) + .send_streaming_message(&versioned_params(), &send_message_request()) .await .unwrap(); let items: Vec<_> = stream.collect().await; @@ -658,7 +658,7 @@ async fn jsonrpc_transport_end_to_end() { let task = transport .get_task( - &jsonrpc_service_params(), + &versioned_params(), &GetTaskRequest { id: "task-1".to_string(), history_length: Some(2), @@ -671,7 +671,7 @@ async fn jsonrpc_transport_end_to_end() { let not_found = transport .get_task( - &jsonrpc_service_params(), + &versioned_params(), &GetTaskRequest { id: "missing".to_string(), history_length: None, @@ -684,7 +684,7 @@ async fn jsonrpc_transport_end_to_end() { let list = transport .list_tasks( - &jsonrpc_service_params(), + &versioned_params(), &ListTasksRequest { context_id: Some("ctx-1".to_string()), status: Some(TaskState::Completed), @@ -702,7 +702,7 @@ async fn jsonrpc_transport_end_to_end() { let canceled = transport .cancel_task( - &jsonrpc_service_params(), + &versioned_params(), &CancelTaskRequest { id: "task-1".to_string(), metadata: None, @@ -715,7 +715,7 @@ async fn jsonrpc_transport_end_to_end() { let cancel_missing = transport .cancel_task( - &jsonrpc_service_params(), + &versioned_params(), &CancelTaskRequest { id: "missing".to_string(), metadata: None, @@ -728,7 +728,7 @@ async fn jsonrpc_transport_end_to_end() { let subscribed = transport .subscribe_to_task( - &jsonrpc_service_params(), + &versioned_params(), &SubscribeToTaskRequest { id: "task-1".to_string(), tenant: None, @@ -740,14 +740,14 @@ async fn jsonrpc_transport_end_to_end() { assert_eq!(events.len(), 1); let created = transport - .create_push_config(&jsonrpc_service_params(), &sample_push_config("cfg-1")) + .create_push_config(&versioned_params(), &sample_push_config("cfg-1")) .await .unwrap(); assert_eq!(created.task_id, "task-1"); let created_missing = transport .create_push_config( - &jsonrpc_service_params(), + &versioned_params(), &TaskPushNotificationConfig { task_id: "missing".to_string(), ..sample_push_config("cfg-1") @@ -759,7 +759,7 @@ async fn jsonrpc_transport_end_to_end() { let fetched = transport .get_push_config( - &jsonrpc_service_params(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -772,7 +772,7 @@ async fn jsonrpc_transport_end_to_end() { let fetched_missing = transport .get_push_config( - &jsonrpc_service_params(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "missing".to_string(), @@ -785,7 +785,7 @@ async fn jsonrpc_transport_end_to_end() { let listed = transport .list_push_configs( - &jsonrpc_service_params(), + &versioned_params(), &ListTaskPushNotificationConfigsRequest { task_id: "task-1".to_string(), page_size: Some(5), @@ -799,7 +799,7 @@ async fn jsonrpc_transport_end_to_end() { transport .delete_push_config( - &jsonrpc_service_params(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "cfg-1".to_string(), @@ -811,7 +811,7 @@ async fn jsonrpc_transport_end_to_end() { let delete_missing = transport .delete_push_config( - &jsonrpc_service_params(), + &versioned_params(), &DeleteTaskPushNotificationConfigRequest { task_id: "task-1".to_string(), id: "missing".to_string(), @@ -824,7 +824,7 @@ async fn jsonrpc_transport_end_to_end() { let card = transport .get_extended_agent_card( - &jsonrpc_service_params(), + &versioned_params(), &GetExtendedAgentCardRequest { tenant: None }, ) .await @@ -842,7 +842,7 @@ async fn rest_transport_push_delivery_end_to_end() { transport .create_push_config( - &ServiceParams::new(), + &versioned_params(), &TaskPushNotificationConfig { task_id: "task-rest-push".to_string(), url: webhook_url, @@ -863,7 +863,7 @@ async fn rest_transport_push_delivery_end_to_end() { request.message.context_id = Some("ctx-rest-push".to_string()); let response = transport - .send_message(&ServiceParams::new(), &request) + .send_message(&versioned_params(), &request) .await .unwrap(); assert!(matches!(response, SendMessageResponse::Task(_))); @@ -927,14 +927,14 @@ async fn jsonrpc_transport_push_delivery_end_to_end() { }); let response = transport - .send_message(&jsonrpc_service_params(), &request) + .send_message(&versioned_params(), &request) .await .unwrap(); assert!(matches!(response, SendMessageResponse::Task(_))); let saved = transport .get_push_config( - &jsonrpc_service_params(), + &versioned_params(), &GetTaskPushNotificationConfigRequest { task_id: "task-rpc-push".to_string(), id: "cfg-rpc".to_string(),