WIP

Author: ishymko

src/a2a/client/transports/grpc.py

@@ -61,17 +61,29 @@ def _map_grpc_error(e: grpc.aio.AioRpcError) -> NoReturn:
 
     # Use grpc_status to cleanly extract the rich Status from the call
     status = rpc_status.from_call(cast('grpc.Call', e))
+    data = None
 
     if status is not None:
+        exception_cls = None
         for detail in status.details:
-            if detail.Is(error_details_pb2.ErrorInfo.DESCRIPTOR):
+            if detail.Is(error_details_pb2.BadRequest.DESCRIPTOR):
+                bad_request = error_details_pb2.BadRequest()
+                detail.Unpack(bad_request)
+                errors = [
+                    {'field': v.field, 'message': v.description}
+                    for v in bad_request.field_violations
+                ]
+                data = {'errors': errors}
+                # Infer InvalidParamsError from BadRequest details
+                exception_cls = A2A_REASON_TO_ERROR.get('INVALID_PARAMS')
+            elif detail.Is(error_details_pb2.ErrorInfo.DESCRIPTOR):
                 error_info = error_details_pb2.ErrorInfo()
                 detail.Unpack(error_info)
-
                 if error_info.domain == 'a2a-protocol.org':
                     exception_cls = A2A_REASON_TO_ERROR.get(error_info.reason)
-                    if exception_cls:
-                        raise exception_cls(status.message) from e
+
+        if exception_cls:
+            raise exception_cls(status.message, data=data) from e
 
     raise A2AClientError(f'gRPC Error {e.code().name}: {e.details()}') from e
 

src/a2a/client/transports/jsonrpc.py

@@ -318,9 +318,10 @@ def _create_jsonrpc_error(self, error_dict: dict[str, Any]) -> Exception:
         """Creates the appropriate A2AError from a JSON-RPC error dictionary."""
         code = error_dict.get('code')
         message = error_dict.get('message', str(error_dict))
+        data = error_dict.get('data')
 
         if isinstance(code, int) and code in _JSON_RPC_ERROR_CODE_TO_A2A_ERROR:
-            return _JSON_RPC_ERROR_CODE_TO_A2A_ERROR[code](message)
+            return _JSON_RPC_ERROR_CODE_TO_A2A_ERROR[code](message, data=data)
 
         # Fallback to general A2AClientError
         return A2AClientError(f'JSON-RPC Error {code}: {message}')

src/a2a/server/request_handlers/grpc_handler.py

@@ -438,16 +438,29 @@ async def abort_context(
                 error.message if hasattr(error, 'message') else str(error)
             )
 
-            # Create standard Status and pack the ErrorInfo
+            # Create standard Status
             status = status_pb2.Status(code=status_code, message=error_msg)
-            detail = any_pb2.Any()
-            detail.Pack(error_info)
-            status.details.append(detail)
+
+            # Exclusive details based on error type:
+            if error.data and error.data.get('errors'):
+                bad_request = error_details_pb2.BadRequest()
+                for err_dict in error.data['errors']:
+                    violation = bad_request.field_violations.add()
+                    violation.field = err_dict.get('field', '')
+                    violation.description = err_dict.get('message', '')
+                any_bad_request = any_pb2.Any()
+                any_bad_request.Pack(bad_request)
+                status.details.append(any_bad_request)
+            else:
+                detail = any_pb2.Any()
+                detail.Pack(error_info)
+                status.details.append(detail)
 
             # Use grpc_status to safely generate standard trailing metadata
             rich_status = rpc_status.to_status(status)
 
             new_metadata: list[tuple[str, str | bytes]] = []
+
             trailing = context.trailing_metadata()
             if trailing:
                 for k, v in trailing:

src/a2a/server/request_handlers/jsonrpc_handler.py

@@ -92,6 +92,7 @@ def _build_error_response(
         jsonrpc_error = model_class(
             code=code,
             message=str(error),
+            data=error.data,
         )
     else:
         jsonrpc_error = JSONRPCInternalError(message=str(error))

tests/integration/test_end_to_end.py

@@ -1,5 +1,5 @@
 from collections.abc import AsyncGenerator
-from typing import NamedTuple
+from typing import Any, NamedTuple
 
 import grpc
 import httpx
@@ -31,6 +31,7 @@
     a2a_pb2_grpc,
 )
 from a2a.utils import TransportProtocol
+from a2a.utils.errors import InvalidParamsError
 
 
 def assert_message_matches(message, expected_role, expected_text):
@@ -546,3 +547,34 @@ async def test_end_to_end_input_required(transport_setups):
         ],
     )
     assert_message_matches(task.status.message, Role.ROLE_AGENT, 'done')
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'empty_request, expected_fields',
+    [
+        (
+            SendMessageRequest(),
+            ['message'],
+        ),
+        (
+            SendMessageRequest(message=Message()),
+            ['message.message_id', 'message.role', 'message.parts'],
+        ),
+    ],
+)
+async def test_end_to_end_validation_errors(
+    transport_setups,
+    empty_request: SendMessageRequest,
+    expected_fields: list[str],
+) -> None:
+    client = transport_setups.client
+
+    with pytest.raises(InvalidParamsError) as exc_info:
+        async for _ in client.send_message(request=empty_request):
+            pass
+
+    errors = exc_info.value.data.get('errors', [])
+    assert {e['field'] for e in errors} == set(expected_fields)
+
+    await client.close()

tests/utils/test_proto_utils.py

@@ -239,3 +239,44 @@ def _message_to_rest_params(self, message: ProtobufMessage) -> QueryParams:
         return httpx.Request(
             'GET', 'http://api.example.com', params=rest_dict
         ).url.params
+
+
+class TestValidateProtoRequiredFields:
+    """Tests for validate_proto_required_fields function."""
+
+    def test_valid_required_fields(self):
+        """Test with all required fields present."""
+        msg = Message(
+            message_id='msg-1',
+            role=Role.ROLE_USER,
+            parts=[Part(text='hello')],
+        )
+        proto_utils.validate_proto_required_fields(msg)
+
+    def test_missing_required_fields(self):
+        """Test with empty message raising InvalidParamsError containing all errors."""
+        from a2a.utils.errors import InvalidParamsError
+
+        msg = Message()
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.validate_proto_required_fields(msg)
+
+        err = exc_info.value
+        errors = err.data.get('errors', []) if err.data else []
+
+        assert {e['field'] for e in errors} == {'message_id', 'role', 'parts'}
+
+    def test_nested_required_fields(self):
+        """Test nested required fields inside TaskStatus."""
+        from a2a.utils.errors import InvalidParamsError
+
+        # Task Status requires 'state'
+        task = Task(id='task-1', status=TaskStatus())
+        with pytest.raises(InvalidParamsError) as exc_info:
+            proto_utils.validate_proto_required_fields(task)
+
+        err = exc_info.value
+        errors = err.data.get('errors', []) if err.data else []
+
+        fields = [e['field'] for e in errors]
+        assert 'status.state' in fields