Fix an issue with ClientFactory not respecting transport URL, add tests

Author: mikeas1

src/a2a/client/client_factory.py

@@ -32,7 +32,7 @@
 
 
 TransportProducer = Callable[
-    [AgentCard, ClientConfig, list[ClientCallInterceptor]],
+    [AgentCard, str, ClientConfig, list[ClientCallInterceptor]],
     ClientTransport,
 ]
 
@@ -68,28 +68,28 @@ def __init__(
     def _register_defaults(self) -> None:
         self.register(
             TransportProtocol.jsonrpc,
-            lambda card, config, interceptors: JsonRpcTransport(
+            lambda card, url, config, interceptors: JsonRpcTransport(
                 config.httpx_client or httpx.AsyncClient(),
                 card,
-                card.url,
+                url,
                 interceptors,
             ),
         )
         self.register(
             TransportProtocol.http_json,
-            lambda card, config, interceptors: RestTransport(
+            lambda card, url, config, interceptors: RestTransport(
                 config.httpx_client or httpx.AsyncClient(),
                 card,
-                card.url,
+                url,
                 interceptors,
             ),
         )
         if GrpcTransport:
             self.register(
                 TransportProtocol.grpc,
-                lambda card, config, interceptors: GrpcTransport(
+                lambda card, url, config, interceptors: GrpcTransport(
                     a2a_pb2_grpc.A2AServiceStub(
-                        config.grpc_channel_factory(card.url)
+                        config.grpc_channel_factory(url)
                     ),
                     card,
                 ),
@@ -121,24 +121,30 @@ def create(
           If there is no valid matching of the client configuration with the
           server configuration, a `ValueError` is raised.
         """
-        server_set = [card.preferred_transport or TransportProtocol.jsonrpc]
+        server_preferred = card.preferred_transport or TransportProtocol.jsonrpc
+        server_set = {server_preferred: card.url}
         if card.additional_interfaces:
-            server_set.extend([x.transport for x in card.additional_interfaces])
+            server_set.update(
+                {x.transport: x.url for x in card.additional_interfaces}
+            )
         client_set = self._config.supported_transports or [
             TransportProtocol.jsonrpc
         ]
         transport_protocol = None
+        transport_url = None
         if self._config.use_client_preference:
             for x in client_set:
                 if x in server_set:
                     transport_protocol = x
+                    transport_url = server_set[x]
                     break
         else:
-            for x in server_set:
+            for x, url in server_set.items():
                 if x in client_set:
                     transport_protocol = x
+                    transport_url = url
                     break
-        if not transport_protocol:
+        if not transport_protocol or not transport_url:
             raise ValueError('no compatible transports found.')
         if transport_protocol not in self._registry:
             raise ValueError(f'no client available for {transport_protocol}')
@@ -148,7 +154,7 @@ def create(
             all_consumers.extend(consumers)
 
         transport = self._registry[transport_protocol](
-            card, self._config, interceptors or []
+            card, transport_url, self._config, interceptors or []
         )
 
         return BaseClient(

src/a2a/client/transports/jsonrpc.py

@@ -64,10 +64,10 @@ def __init__(
         interceptors: list[ClientCallInterceptor] | None = None,
     ):
         """Initializes the JsonRpcTransport."""
-        if agent_card:
-            self.url = agent_card.url
-        elif url:
+        if url:
             self.url = url
+        elif agent_card:
+            self.url = agent_card.url
         else:
             raise ValueError('Must provide either agent_card or url')
 

src/a2a/client/transports/rest.py

@@ -45,10 +45,10 @@ def __init__(
         interceptors: list[ClientCallInterceptor] | None = None,
     ):
         """Initializes the RestTransport."""
-        if agent_card:
-            self.url = agent_card.url
-        elif url:
+        if url:
             self.url = url
+        elif agent_card:
+            self.url = agent_card.url
         else:
             raise ValueError('Must provide either agent_card or url')
         if self.url.endswith('/'):

tests/client/test_client_factory.py

@@ -0,0 +1,93 @@
+"""Tests for the ClientFactory."""
+
+import httpx
+import pytest
+
+from a2a.client import ClientConfig, ClientFactory
+from a2a.client.transports import JsonRpcTransport, RestTransport
+from a2a.types import (
+    AgentCard,
+    AgentCapabilities,
+    AgentInterface,
+    TransportProtocol,
+)
+
+
+@pytest.fixture
+def base_agent_card() -> AgentCard:
+    """Provides a base AgentCard for tests."""
+    return AgentCard(
+        name="Test Agent",
+        description="An agent for testing.",
+        url="http://primary-url.com",
+        version="1.0.0",
+        capabilities=AgentCapabilities(),
+        skills=[],
+        default_input_modes=[],
+        default_output_modes=[],
+        preferred_transport=TransportProtocol.jsonrpc,
+    )
+
+
+def test_client_factory_selects_preferred_transport(base_agent_card: AgentCard):
+    """Verify that the factory selects the preferred transport by default."""
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_transports=[TransportProtocol.jsonrpc, TransportProtocol.http_json],
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, JsonRpcTransport)
+    assert client._transport.url == "http://primary-url.com"
+
+
+def test_client_factory_selects_secondary_transport_url(base_agent_card: AgentCard):
+    """Verify that the factory selects the correct URL for a secondary transport."""
+    base_agent_card.additional_interfaces = [
+        AgentInterface(
+            transport=TransportProtocol.http_json, url="http://secondary-url.com"
+        )
+    ]
+    # Client prefers REST, which is available as a secondary transport
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_transports=[TransportProtocol.http_json, TransportProtocol.jsonrpc],
+        use_client_preference=True,
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, RestTransport)
+    assert client._transport.url == "http://secondary-url.com"
+
+
+def test_client_factory_server_preference(base_agent_card: AgentCard):
+    """Verify that the factory respects server transport preference."""
+    base_agent_card.preferred_transport = TransportProtocol.http_json
+    base_agent_card.additional_interfaces = [
+        AgentInterface(
+            transport=TransportProtocol.jsonrpc, url="http://secondary-url.com"
+        )
+    ]
+    # Client supports both, but server prefers REST
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_transports=[TransportProtocol.jsonrpc, TransportProtocol.http_json],
+    )
+    factory = ClientFactory(config)
+    client = factory.create(base_agent_card)
+
+    assert isinstance(client._transport, RestTransport)
+    assert client._transport.url == "http://primary-url.com"
+
+
+def test_client_factory_no_compatible_transport(base_agent_card: AgentCard):
+    """Verify that the factory raises an error if no compatible transport is found."""
+    config = ClientConfig(
+        httpx_client=httpx.AsyncClient(),
+        supported_transports=[TransportProtocol.grpc],
+    )
+    factory = ClientFactory(config)
+    with pytest.raises(ValueError, match="no compatible transports found"):
+        factory.create(base_agent_card)