Implement a convenience method for constructing clients

Author: mikeas1

src/a2a/client/client_factory.py

@@ -3,10 +3,12 @@
 import logging
 
 from collections.abc import Callable
+from typing import Any
 
 import httpx
 
 from a2a.client.base_client import BaseClient
+from a2a.client.card_resolver import A2ACardResolver
 from a2a.client.client import Client, ClientConfig, Consumer
 from a2a.client.middleware import ClientCallInterceptor
 from a2a.client.transports.base import ClientTransport
@@ -101,6 +103,61 @@ def _register_defaults(
                 GrpcTransport.create,
             )
 
+    @classmethod
+    async def connect(  # noqa: PLR0913
+        cls,
+        agent: str | AgentCard,
+        client_config: ClientConfig | None = None,
+        consumers: list[Consumer] | None = None,
+        interceptors: list[ClientCallInterceptor] | None = None,
+        relative_card_path: str | None = None,
+        resolver_http_kwargs: dict[str, Any] | None = None,
+        extra_transports: dict[str, TransportProducer] | None = None,
+    ) -> Client:
+        """Convenience method for constructing a client.
+
+        Constructs a client that connects to the specified agent. Note that
+        creating multiple clients via this method is less efficient than
+        constructing an instance of ClientFactory and reusing that.
+
+        Args:
+          agent: The base URL of the agent, or the AgentCard to connect to.
+          client_config: The ClientConfig to use when connecting to the agent.
+          consumers: A list of `Consumer` methods to pass responses to.
+          interceptors: A list of interceptors to use for each request. These
+            are used for things like attaching credentials or http headers
+            to all outbound requests.
+          relative_card_path: If the agent field is a URL, this value is used as
+            the relative path when resolving the agent card. See
+            A2AAgentCardResolver.get_agent_card for more details.
+          resolver_http_kwargs: Dictionary of arguments to provide to the httpx
+            client when resolving the agent card. This value is provided to
+            A2AAgentCardResolver.get_agent_card as the http_kwargs parameter.
+          extra_transports: Additional transport protocols to enable when
+            constructing the client.
+
+        Returns:
+          A `Client` object.
+        """
+        client_config = client_config or ClientConfig()
+        if isinstance(agent, str):
+            if not client_config.httpx_client:
+                async with httpx.AsyncClient() as client:
+                    resolver = A2ACardResolver(client, agent)
+                    card = await resolver.get_agent_card()
+            else:
+                resolver = A2ACardResolver(client_config.httpx_client, agent)
+                card = await resolver.get_agent_card(
+                    relative_card_path=relative_card_path,
+                    http_kwargs=resolver_http_kwargs,
+                )
+        else:
+            card = agent
+        factory = cls(client_config)
+        for label, generator in (extra_transports or {}).items():
+            factory.register(label, generator)
+        return factory.create(card, consumers, interceptors)
+
     def register(self, label: str, generator: TransportProducer) -> None:
         """Register a new transport producer for a given transport label."""
         self._registry[label] = generator