fix: address PR a2aproject#1117 review feedback

- Support async resolvers (e.g. aiodns) by detecting and awaiting
  coroutine return values from custom Resolver callbacks
- Convert ip_address ValueError from resolver output to InvalidUrlError
  for consistent error handling
- Strip IPv6 brackets in _normalize_host so allow_hosts=['[::1]']
  correctly matches parsed hostname '::1'
- Add 3 new test cases covering these fixes (31 total, 96% coverage)

Author: Linux2010

src/a2a/utils/url_validator.py

@@ -38,17 +38,22 @@
 
 import asyncio
 import contextlib
+import inspect
 import ipaddress
 import socket
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
+from typing import cast
 from urllib.parse import SplitResult, urlsplit
 
 
 IPAddress = ipaddress.IPv4Address | ipaddress.IPv6Address
-Resolver = Callable[[str, int | None], Sequence[IPAddress | str]]
+Resolver = Callable[
+    [str, int | None],
+    Sequence[IPAddress | str] | Awaitable[Sequence[IPAddress | str]],
+]
 
 
 class InvalidUrlError(ValueError):
@@ -215,7 +220,13 @@ async def _resolve_host(
 
         try:
             if self._resolver is not None:
-                resolved = self._resolver(host, port)
+                result = self._resolver(host, port)
+                # Support async resolvers (e.g. aiodns) that return
+                # coroutines / awaitables.
+                if inspect.isawaitable(result):
+                    resolved = cast('Sequence[IPAddress | str]', await result)
+                else:
+                    resolved = result
             else:
                 loop = asyncio.get_running_loop()
                 address_info = await loop.getaddrinfo(
@@ -231,20 +242,30 @@ async def _resolve_host(
 
         # Normalise resolver output: accept both str and IPAddress
         # instances (fixes review comment on PR #1114).
-        addresses = tuple(
-            dict.fromkeys(
-                addr
-                if isinstance(
-                    addr, (ipaddress.IPv4Address, ipaddress.IPv6Address)
+        try:
+            addresses = tuple(
+                dict.fromkeys(
+                    addr
+                    if isinstance(
+                        addr, (ipaddress.IPv4Address, ipaddress.IPv6Address)
+                    )
+                    else ipaddress.ip_address(addr)
+                    for addr in resolved
                 )
-                else ipaddress.ip_address(addr)
-                for addr in resolved
             )
-        )
+        except ValueError as exc:
+            raise InvalidUrlError(
+                f'Resolver returned invalid address for {host!r}: {exc}'
+            ) from exc
         if not addresses:
             raise InvalidUrlError(f'URL host {host!r} did not resolve.')
         return addresses
 
 
 def _normalize_host(host: str) -> str:
-    return host.rstrip('.').lower()
+    """Normalize a hostname for comparison.
+
+    Strips trailing dots, lowercases, and removes surrounding square
+    brackets from IPv6 literals (e.g. ``[::1]`` → ``::1``).
+    """
+    return host.strip('[]').rstrip('.').lower()

tests/utils/test_url_validator.py

@@ -374,6 +374,23 @@ def resolver(host: str, port: int | None) -> list[str]:
     assert result.addresses == (ipaddress.ip_address('127.0.0.1'),)
 
 
+@pytest.mark.asyncio
+async def test_block_private_networks_allow_ipv6_with_brackets() -> None:
+    """allow_hosts strips surrounding brackets from IPv6 literals."""
+
+    def resolver(host: str, port: int | None) -> list[str]:
+        return ['::1']
+
+    validator = UrlValidator(
+        [BlockPrivateNetworks(allow_hosts=['[::1]'])],
+        resolver=resolver,
+    )
+
+    result = await validator.validate('http://[::1]/callback')
+
+    assert result.addresses == (ipaddress.ip_address('::1'),)
+
+
 # ---------------------------------------------------------------------------
 # Resolver returning IPAddress objects (PR #1114 review fix)
 # ---------------------------------------------------------------------------
@@ -393,6 +410,35 @@ def resolver(host: str, port: int | None) -> list[ipaddress.IPv4Address]:
     assert result.addresses == (ipaddress.ip_address('93.184.216.34'),)
 
 
+@pytest.mark.asyncio
+async def test_async_resolver_is_awaited() -> None:
+    """Custom resolvers may return awaitables (e.g. aiodns)."""
+
+    async def resolver(host: str, port: int | None) -> list[str]:
+        return ['93.184.216.34']
+
+    validator = UrlValidator(resolver=resolver)
+
+    result = await validator.validate('http://example.com/')
+
+    assert result.addresses == (ipaddress.ip_address('93.184.216.34'),)
+
+
+@pytest.mark.asyncio
+async def test_resolver_returning_invalid_address_raises_invalid_url_error() -> (
+    None
+):
+    """Resolver returning non-IP strings raises InvalidUrlError."""
+
+    def resolver(host: str, port: int | None) -> list[str]:
+        return ['not-an-ip-address']
+
+    validator = UrlValidator(resolver=resolver)
+
+    with pytest.raises(InvalidUrlError, match='invalid address'):
+        await validator.validate('http://example.com/')
+
+
 # ---------------------------------------------------------------------------
 # Rule composition
 # ---------------------------------------------------------------------------