feat: add async context manager support to BaseClient (#688)

# Description

Thank you for opening a Pull Request!
Before submitting your PR, there are a few things you can do to make
sure it goes smoothly:

- [x] Follow the [`CONTRIBUTING`
Guide](https://github.com/a2aproject/a2a-python/blob/main/CONTRIBUTING.md).
- [x] Make your Pull Request title in the
<https://www.conventionalcommits.org/> specification.
- Important Prefixes for
[release-please](https://github.com/googleapis/release-please):
- `fix:` which represents bug fixes, and correlates to a
[SemVer](https://semver.org/) patch.
- `feat:` represents a new feature, and correlates to a SemVer minor.
- `feat!:`, or `fix!:`, `refactor!:`, etc., which represent a breaking
change (indicated by the `!`) and will result in a SemVer major.
- [x] Ensure the tests and linter pass (Run `bash scripts/format.sh`
from the repository root to format)
- [x] Appropriate docs were updated (if necessary)

Follow-up to #682, as suggested by @ishymko in the
[review](#682 (review)).

This extends the async context manager pattern to `BaseClient`, which
wraps `ClientTransport` and also exposes a `close()` method.

Fixes #674 🦕

## Problem

`BaseClient` delegates resource cleanup to its underlying
`ClientTransport` via `close()`, but doesn't implement
`__aenter__`/`__aexit__`. This means clients cannot be used with `async
with`, leading to the same resource leak risk that #682 solved for
transports:

```python
client = BaseClient(card=card, config=config, transport=transport, consumers=[], middleware=[])
result = await client.send_message(msg)  # if this raises, close() is never called
await client.close()
```

## Fix

Added `__aenter__` and `__aexit__` methods to `BaseClient` in
`src/a2a/client/base_client.py`:

`__aenter__` returns `self`
`__aexit__ `awaits `close()`

This enables the standard async context manager pattern:

```python
async with BaseClient(card=card, config=config, transport=transport, consumers=[], middleware=[]) as client:
    async for event in client.send_message(msg):
        ...
    # close() called automatically, even on exceptions
```

This is a non-breaking, additive change. Calling `close()` manually or
via `try/finally` continues to work exactly as before.

## Test

Tests were added to `tests/client/test_base_client.py`, following the
same approach as the `ClientTransport` tests from #682.

Release-As: 0.3.23

Author: cchinchilla-dev

src/a2a/client/base_client.py

@@ -1,6 +1,9 @@
 from collections.abc import AsyncIterator, Callable
+from types import TracebackType
 from typing import Any
 
+from typing_extensions import Self
+
 from a2a.client.client import (
     Client,
     ClientCallContext,
@@ -43,6 +46,19 @@ def __init__(
         self._config = config
         self._transport = transport
 
+    async def __aenter__(self) -> Self:
+        """Enters the async context manager, returning the client itself."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exits the async context manager, ensuring close() is called."""
+        await self.close()
+
     async def send_message(
         self,
         request: Message,

tests/client/test_base_client.py

@@ -87,6 +87,26 @@ async def test_transport_async_context_manager_on_exception() -> None:
         transport.close.assert_awaited_once()
 
 
+@pytest.mark.asyncio
+async def test_base_client_async_context_manager(
+    base_client: BaseClient, mock_transport: AsyncMock
+) -> None:
+    async with base_client as client:
+        assert client is base_client
+        mock_transport.close.assert_not_awaited()
+    mock_transport.close.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_base_client_async_context_manager_on_exception(
+    base_client: BaseClient, mock_transport: AsyncMock
+) -> None:
+    with pytest.raises(RuntimeError, match='boom'):
+        async with base_client:
+            raise RuntimeError('boom')
+    mock_transport.close.assert_awaited_once()
+
+
 @pytest.mark.asyncio
 async def test_send_message_streaming(
     base_client: BaseClient, mock_transport: MagicMock, sample_message: Message