feat(compat): REST and JSONRPC clients compatible with 0.3 servers. (#798)

Fixes #742

Author: bartek-w

src/a2a/client/client_factory.py

@@ -42,7 +42,6 @@
 except ImportError:
     CompatGrpcTransport = None  # type: ignore # pyright: ignore
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -92,24 +91,88 @@ def _register_defaults(self, supported: list[str]) -> None:
         # Empty support list implies JSON-RPC only.
 
         if TransportProtocol.JSONRPC in supported or not supported:
-            self.register(
-                TransportProtocol.JSONRPC,
-                lambda card, url, config, interceptors: JsonRpcTransport(
+
+            def jsonrpc_transport_producer(
+                card: AgentCard,
+                url: str,
+                config: ClientConfig,
+                interceptors: list[ClientCallInterceptor],
+            ) -> ClientTransport:
+                interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[TransportProtocol.JSONRPC],
+                    url=url,
+                )
+                version = (
+                    interface.protocol_version
+                    if interface
+                    else PROTOCOL_VERSION_CURRENT
+                )
+
+                if ClientFactory._is_legacy_version(version):
+                    from a2a.compat.v0_3.jsonrpc_transport import (  # noqa: PLC0415
+                        CompatJsonRpcTransport,
+                    )
+
+                    return CompatJsonRpcTransport(
+                        cast('httpx.AsyncClient', config.httpx_client),
+                        card,
+                        url,
+                        interceptors,
+                    )
+
+                return JsonRpcTransport(
                     cast('httpx.AsyncClient', config.httpx_client),
                     card,
                     url,
                     interceptors,
-                ),
+                )
+
+            self.register(
+                TransportProtocol.JSONRPC,
+                jsonrpc_transport_producer,
             )
         if TransportProtocol.HTTP_JSON in supported:
-            self.register(
-                TransportProtocol.HTTP_JSON,
-                lambda card, url, config, interceptors: RestTransport(
+
+            def rest_transport_producer(
+                card: AgentCard,
+                url: str,
+                config: ClientConfig,
+                interceptors: list[ClientCallInterceptor],
+            ) -> ClientTransport:
+                interface = ClientFactory._find_best_interface(
+                    list(card.supported_interfaces),
+                    protocol_bindings=[TransportProtocol.HTTP_JSON],
+                    url=url,
+                )
+                version = (
+                    interface.protocol_version
+                    if interface
+                    else PROTOCOL_VERSION_CURRENT
+                )
+
+                if ClientFactory._is_legacy_version(version):
+                    from a2a.compat.v0_3.rest_transport import (  # noqa: PLC0415
+                        CompatRestTransport,
+                    )
+
+                    return CompatRestTransport(
+                        cast('httpx.AsyncClient', config.httpx_client),
+                        card,
+                        url,
+                        interceptors,
+                    )
+
+                return RestTransport(
                     cast('httpx.AsyncClient', config.httpx_client),
                     card,
                     url,
                     interceptors,
-                ),
+                )
+
+            self.register(
+                TransportProtocol.HTTP_JSON,
+                rest_transport_producer,
             )
         if TransportProtocol.GRPC in supported:
             if GrpcTransport is None:
@@ -137,27 +200,17 @@ def grpc_transport_producer(
                     else PROTOCOL_VERSION_CURRENT
                 )
 
-                compat_transport = CompatGrpcTransport
-                if version and compat_transport is not None:
-                    try:
-                        v = Version(version)
-                        if (
-                            Version(PROTOCOL_VERSION_0_3)
-                            <= v
-                            < Version(PROTOCOL_VERSION_1_0)
-                        ):
-                            return compat_transport.create(
-                                card, url, config, interceptors
-                            )
-                    except InvalidVersion:
-                        pass
-
-                grpc_transport = GrpcTransport
-                if grpc_transport is not None:
-                    return grpc_transport.create(
+                if (
+                    ClientFactory._is_legacy_version(version)
+                    and CompatGrpcTransport is not None
+                ):
+                    return CompatGrpcTransport.create(
                         card, url, config, interceptors
                     )
 
+                if GrpcTransport is not None:
+                    return GrpcTransport.create(card, url, config, interceptors)
+
                 raise ImportError(
                     'GrpcTransport is not available. '
                     'You can install it with \'pip install "a2a-sdk[grpc]"\''
@@ -168,6 +221,21 @@ def grpc_transport_producer(
                 grpc_transport_producer,
             )
 
+    @staticmethod
+    def _is_legacy_version(version: str | None) -> bool:
+        """Determines if the given version is a legacy protocol version (>=0.3 and <1.0)."""
+        if not version:
+            return False
+        try:
+            v = Version(version)
+            return (
+                Version(PROTOCOL_VERSION_0_3)
+                <= v
+                < Version(PROTOCOL_VERSION_1_0)
+            )
+        except InvalidVersion:
+            return False
+
     @staticmethod
     def _find_best_interface(
         interfaces: list[AgentInterface],

src/a2a/compat/v0_3/grpc_transport.py

@@ -135,10 +135,10 @@ async def send_message(
                     proto_utils.FromProto.task(resp_proto.task)
                 )
             )
-        if which == 'message':
+        if which == 'msg':
             return a2a_pb2.SendMessageResponse(
                 message=conversions.to_core_message(
-                    proto_utils.FromProto.message(resp_proto.message)
+                    proto_utils.FromProto.message(resp_proto.msg)
                 )
             )
         return a2a_pb2.SendMessageResponse()