From 5fd86e04b0b5e3cb94a723c48704205629a079f8 Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Tue, 10 Nov 2026 12:53:27 +0000 Subject: [PATCH 1/7] feat: add call wrapper for client,server --- src/a2a/client/base_client.py | 32 ++++++++++++++++++++--------- src/a2a/plugins/base.py | 23 +++++++++++++++++++-- src/a2a/plugins/manager.py | 38 +++++++++++++++++++++++++++++++++-- 3 files changed, 80 insertions(+), 13 deletions(-) diff --git a/src/a2a/client/base_client.py b/src/a2a/client/base_client.py index fbcdb955e..c0f53d873 100644 --- a/src/a2a/client/base_client.py +++ b/src/a2a/client/base_client.py @@ -38,7 +38,8 @@ class BaseClient(Client): """Base implementation of the A2A client, containing transport-independent logic. Client plugin hooks run around every call: ``before_client_request`` before - the interceptors, ``after_client_request`` after them. + the interceptors, ``after_client_request`` after them, and + ``wrap_client_call`` """ def __init__( @@ -435,8 +436,13 @@ async def _execute_with_interceptors( request = self._client_request(input_data, method, context) await plugins.before_client_request(request) try: - result = await self._call_through_interceptors( - request.payload, method, request.context, transport_call + # Reads request fields at call time, so a plugin can change them + # before calling, and each retry makes a fresh call. + result = await plugins.wrap_client_call( + request, + lambda: self._call_through_interceptors( + request.payload, method, request.context, transport_call + ), ) except Exception as e: await plugins.after_client_request( @@ -516,14 +522,20 @@ async def _execute_stream_with_interceptors( request = self._client_request(input_data, method, context) await plugins.before_client_request(request) + events = self._stream_through_interceptors( + request.payload, method, request.context, transport_call + ) error: BaseException | None = None try: - async with aclosing( - self._stream_through_interceptors( - request.payload, method, request.context, transport_call - ) - ) as events: - async for event in events: + try: + while True: + # None marks the end of the stream, so StopAsyncIteration + # never passes through plugin code. + event = await plugins.wrap_client_call( + request, lambda: anext(events, None) + ) + if event is None: + break await plugins.after_client_request( ClientResponse( request.method, @@ -534,6 +546,8 @@ async def _execute_stream_with_interceptors( ) ) yield event + finally: + await plugins.wrap_client_call(request, events.aclose) except Exception as e: error = e raise diff --git a/src/a2a/plugins/base.py b/src/a2a/plugins/base.py index 23a51eb53..f65135fb3 100644 --- a/src/a2a/plugins/base.py +++ b/src/a2a/plugins/base.py @@ -5,15 +5,18 @@ Interceptor hooks (``before_*``) may modify their argument or reject the call by raising. Exceptions from ``after_*`` and observer hooks (``on_*``) are -logged and swallowed by the plugin manager. +logged and swallowed by the plugin manager. ``wrap_*_call`` hooks wrap the +call itself, so their exceptions propagate to the caller. """ from __future__ import annotations -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Any if TYPE_CHECKING: + from collections.abc import Awaitable, Callable + from a2a.plugins.types import ( ClientRequest, ClientResponse, @@ -46,6 +49,14 @@ async def before_handler_run(self, request: ServerRequest) -> None: async def after_handler_run(self, response: ServerResponse) -> None: """Called with the handler result, per stream event, and at the end.""" + async def wrap_server_call( + self, + request: ServerRequest, + call: Callable[[], Awaitable[Any]], + ) -> Any: + """Runs around each call into the handler.TODO wire.""" + return await call() + class ClientPlugin(Plugin): """Hooks around each request made by an A2A `Client`.""" @@ -56,6 +67,14 @@ async def before_client_request(self, request: ClientRequest) -> None: async def after_client_request(self, response: ClientResponse) -> None: """Called with the result, per stream event, and at the end.""" + async def wrap_client_call( + self, + request: ClientRequest, + call: Callable[[], Awaitable[Any]], + ) -> Any: + """Runs around each call the client makes for a request.""" + return await call() + class ExecutionPlugin(Plugin): """Hooks around `AgentExecutor.execute`, which runs outside the request.""" diff --git a/src/a2a/plugins/manager.py b/src/a2a/plugins/manager.py index 0b2af80d9..4f2df458a 100644 --- a/src/a2a/plugins/manager.py +++ b/src/a2a/plugins/manager.py @@ -2,9 +2,10 @@ from __future__ import annotations +import functools import logging -from typing import TYPE_CHECKING, TypeVar +from typing import TYPE_CHECKING, Any, TypeVar from a2a.plugins.base import ( ClientPlugin, @@ -18,7 +19,7 @@ if TYPE_CHECKING: - from collections.abc import Awaitable + from collections.abc import Awaitable, Callable from a2a.plugins.types import ( ClientRequest, @@ -95,6 +96,12 @@ def _select( ] +def _overriding(plugins: list[_P], base: type[_P], hook: str) -> list[_P]: + """Returns the plugins that override ``base.hook``.""" + default = getattr(base, hook) + return [p for p in plugins if getattr(type(p), hook) is not default] + + class SequentialPluginManager(PluginManager): """Runs plugins one after another in registration order. @@ -105,6 +112,8 @@ class SequentialPluginManager(PluginManager): swallowed. - Observer hooks (``on_*``) run in registration order. Their exceptions are logged and swallowed. + - ``wrap_*_call`` hooks nest: the first registered plugin is the + outermost. Their exceptions propagate. """ name = 'sequential' @@ -129,6 +138,13 @@ def __init__(self, *plugins: Plugin): self._push: list[PushPlugin] = _select( plugins, PushPlugin, 'has_push_hooks' ) + # Only plugins that override the wrap hooks add a wrapping layer. + self._server_wraps = _overriding( + self._server, ServerPlugin, 'wrap_server_call' + ) + self._client_wraps = _overriding( + self._client, ClientPlugin, 'wrap_client_call' + ) @property def plugins(self) -> tuple[Plugin, ...]: @@ -181,6 +197,15 @@ async def after_handler_run(self, response: ServerResponse) -> None: # noqa: D1 plugin, 'after_handler_run', plugin.after_handler_run(response) ) + async def wrap_server_call( # noqa: D102 + self, + request: ServerRequest, + call: Callable[[], Awaitable[Any]], + ) -> Any: + for plugin in reversed(self._server_wraps): + call = functools.partial(plugin.wrap_server_call, request, call) + return await call() + # --- client --- async def before_client_request(self, request: ClientRequest) -> None: # noqa: D102 @@ -209,6 +234,15 @@ async def after_client_request(self, response: ClientResponse) -> None: # noqa: plugin.after_client_request(response), ) + async def wrap_client_call( # noqa: D102 + self, + request: ClientRequest, + call: Callable[[], Awaitable[Any]], + ) -> Any: + for plugin in reversed(self._client_wraps): + call = functools.partial(plugin.wrap_client_call, request, call) + return await call() + # --- execution --- async def before_execution(self, request_context: RequestContext) -> None: # noqa: D102 From 778f4444c2ca40c40126da03798ad1527ffbcf63 Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Tue, 17 Nov 2026 10:38:46 +0000 Subject: [PATCH 2/7] tests: add tests to client wiring --- tests/client/test_base_client_plugins.py | 158 ++++++++++++++++++++++- 1 file changed, 154 insertions(+), 4 deletions(-) diff --git a/tests/client/test_base_client_plugins.py b/tests/client/test_base_client_plugins.py index dbb375e7e..48a8e2347 100644 --- a/tests/client/test_base_client_plugins.py +++ b/tests/client/test_base_client_plugins.py @@ -1,3 +1,4 @@ +from collections.abc import Awaitable, Callable from typing import Any from unittest.mock import AsyncMock @@ -47,6 +48,9 @@ def __init__(self) -> None: def hooks(self, name: str) -> list[Any]: return [arg for hook, arg in self.calls if hook == name] + def names(self) -> list[str]: + return [hook for hook, _ in self.calls] + async def before_client_request(self, request: ClientRequest) -> None: params = dict(request.context.service_parameters or {}) params['x-trace'] = 'abc' @@ -56,6 +60,15 @@ async def before_client_request(self, request: ClientRequest) -> None: async def after_client_request(self, response: ClientResponse) -> None: self.calls.append(('after_client_request', response)) + async def wrap_client_call( + self, request: ClientRequest, call: Callable[[], Awaitable[Any]] + ) -> Any: + self.calls.append(('wrap_enter', request)) + try: + return await call() + finally: + self.calls.append(('wrap_exit', request)) + def card(streaming: bool = True) -> AgentCard: return AgentCard( @@ -99,6 +112,18 @@ def status_event(state: TaskState) -> StreamResponse: ) +def wrapping(label: str, log: list[str]) -> plugins.ClientPlugin: + class Wrapping(plugins.ClientPlugin): + async def wrap_client_call(self, request, call): + log.append(f'{label}-enter') + try: + return await call() + finally: + log.append(f'{label}-exit') + + return Wrapping() + + @pytest.fixture(autouse=True) def restore_global(): previous = plugins.get_global() @@ -127,6 +152,13 @@ async def test_unary_call_runs_hooks(): # The header added by the plugin reaches the transport. sent_context = transport.get_task.call_args.kwargs['context'] assert sent_context.service_parameters['x-trace'] == 'abc' + # One wrap around the call, inside the before and after hooks. + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] @pytest.mark.asyncio @@ -165,10 +197,10 @@ async def stream(request, *, context=None): transport.send_message_streaming = stream - events = [ - e - async for e in client(recorder, transport).send_message(send_request()) - ] + events = [] + async for e in client(recorder, transport).send_message(send_request()): + events.append(e) + recorder.calls.append(('consumer', None)) assert events == streamed (request,) = recorder.hooks('before_client_request') @@ -179,6 +211,25 @@ async def stream(request, *, context=None): assert responses[-1].is_final assert responses[-1].payload is None assert responses[-1].error is None + # Every step is wrapped separately, and each wrap closes before the + # consumer sees the event: one step per event, one for the end of the + # stream, one for the close. + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + 'consumer', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + 'consumer', + 'wrap_enter', + 'wrap_exit', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] @pytest.mark.asyncio @@ -196,6 +247,17 @@ async def stream(request, *, context=None): await events.aclose() assert recorder.hooks('after_client_request')[-1].is_final + # Abandoning the stream leaves no wrap open: one step for the consumed + # event, one for the close. + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] @pytest.mark.asyncio @@ -209,6 +271,13 @@ async def test_transport_errors_reach_after_client_request(): (response,) = recorder.hooks('after_client_request') assert isinstance(response.error, ConnectionError) + # A failing call still exits its wrap before the after hook runs. + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] async def failing(request, *, context=None): yield status_event(TaskState.TASK_STATE_WORKING) @@ -222,6 +291,18 @@ async def failing(request, *, context=None): assert isinstance( recorder.hooks('after_client_request')[-1].error, ConnectionError ) + # The step that raises exits its wrap, as does the close. + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + 'wrap_enter', + 'wrap_exit', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] @pytest.mark.asyncio @@ -389,3 +470,72 @@ async def stream(request, *, context=None): assert all( r.method == 'subscribe' for r in recorder.hooks('after_client_request') ) + + +@pytest.mark.parametrize('streaming', [False, True]) +@pytest.mark.asyncio +async def test_wraps_nest_in_registration_order(streaming): + """Wraps nest in registration order; one without the hook adds no layer.""" + log: list[str] = [] + transport = AsyncMock(spec=ClientTransport) + transport.get_task.return_value = Task(id='t-1') + + async def stream(request, *, context=None): + yield status_event(TaskState.TASK_STATE_WORKING) + + transport.send_message_streaming = stream + c = BaseClient( + card(), + ClientConfig(streaming=True), + transport, + [], + plugins=plugins.sequential( + wrapping('a', log), + # A plugin that does not override the hook adds no layer. + plugins.ClientPlugin(), + wrapping('b', log), + ), + ) + + if streaming: + async for _ in c.send_message(send_request()): + pass + else: + await c.get_task(GetTaskRequest(id='t-1')) + + step = ['a-enter', 'b-enter', 'b-exit', 'a-exit'] + assert log[: len(step)] == step + assert len(log) == len(step) * (3 if streaming else 1) + + +@pytest.mark.asyncio +async def test_error_raised_inside_the_wrap_reaches_the_caller(): + """A plugin raising in its wrap skips the transport and fails the call.""" + + class Boom(plugins.ClientPlugin): + async def wrap_client_call(self, request, call): + raise RuntimeError('plugin bug') + + recorder = Recorder() + transport = AsyncMock(spec=ClientTransport) + c = BaseClient( + card(), + ClientConfig(), + transport, + [], + plugins=plugins.sequential(recorder, Boom()), + ) + + with pytest.raises(RuntimeError): + await c.get_task(GetTaskRequest(id='t-1')) + + transport.get_task.assert_not_called() + assert recorder.names() == [ + 'before_client_request', + 'wrap_enter', + 'wrap_exit', + 'after_client_request', + ] + assert isinstance( + recorder.hooks('after_client_request')[-1].error, RuntimeError + ) From 7165180853746f3002b5d67790f527d08ab61bea Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Tue, 17 Nov 2026 11:57:26 +0000 Subject: [PATCH 3/7] feat: add server plumbing + tests --- src/a2a/plugins/base.py | 2 +- .../server/request_handlers/_plugin_hooks.py | 32 ++-- ...test_default_request_handler_v2_plugins.py | 156 +++++++++++++++++- 3 files changed, 173 insertions(+), 17 deletions(-) diff --git a/src/a2a/plugins/base.py b/src/a2a/plugins/base.py index f65135fb3..b95adcf1b 100644 --- a/src/a2a/plugins/base.py +++ b/src/a2a/plugins/base.py @@ -54,7 +54,7 @@ async def wrap_server_call( request: ServerRequest, call: Callable[[], Awaitable[Any]], ) -> Any: - """Runs around each call into the handler.TODO wire.""" + """Runs around each call the handler makes for a request.""" return await call() diff --git a/src/a2a/server/request_handlers/_plugin_hooks.py b/src/a2a/server/request_handlers/_plugin_hooks.py index 87a68c9ff..fb7d487a0 100644 --- a/src/a2a/server/request_handlers/_plugin_hooks.py +++ b/src/a2a/server/request_handlers/_plugin_hooks.py @@ -64,15 +64,23 @@ async def stream_wrapper( yield event return - await plugins.before_handler_run( - ServerRequest(method, params, context, self.agent_card) + request = ServerRequest( + method, params, context, self.agent_card ) + await plugins.before_handler_run(request) + events = func(self, params, context, *args, **kwargs) error: BaseException | None = None try: - async with aclosing( - func(self, params, context, *args, **kwargs) - ) as events: - async for event in events: + try: + while True: + # None marks the end of the stream, so + # StopAsyncIteration never passes through plugin + # code. + event = await plugins.wrap_server_call( + request, lambda: anext(events, None) + ) + if event is None: + break await plugins.after_handler_run( ServerResponse( method, @@ -83,6 +91,8 @@ async def stream_wrapper( ) ) yield event + finally: + await plugins.wrap_server_call(request, events.aclose) except (Exception, asyncio.CancelledError) as e: error = e raise @@ -106,11 +116,13 @@ async def unary_wrapper( if not plugins.has_server_hooks: return await func(self, params, context, *args, **kwargs) - await plugins.before_handler_run( - ServerRequest(method, params, context, self.agent_card) - ) + request = ServerRequest(method, params, context, self.agent_card) + await plugins.before_handler_run(request) try: - result = await func(self, params, context, *args, **kwargs) + result = await plugins.wrap_server_call( + request, + lambda: func(self, params, context, *args, **kwargs), + ) except (Exception, asyncio.CancelledError) as e: # A cancelled call still gets its after call, as streams do. await plugins.after_handler_run( diff --git a/tests/server/request_handlers/test_default_request_handler_v2_plugins.py b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py index 3fdc194f7..ea289eb4a 100644 --- a/tests/server/request_handlers/test_default_request_handler_v2_plugins.py +++ b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py @@ -71,6 +71,27 @@ ) +WRAP_HOOKS = ( + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + 'consumer', +) + + +def wrapping(label: str, log: list[str]) -> plugins.ServerPlugin: + class Wrapping(plugins.ServerPlugin): + async def wrap_server_call(self, request, call): + log.append(f'{label}-enter') + try: + return await call() + finally: + log.append(f'{label}-exit') + + return Wrapping() + + class Recorder(CompletePlugin, ExecutionPlugin, TaskObserverPlugin, PushPlugin): """Records (hook, argument) for every hook call.""" @@ -91,6 +112,17 @@ async def before_handler_run(self, request: ServerRequest) -> None: async def after_handler_run(self, response: ServerResponse) -> None: self.calls.append(('after_handler_run', response)) + async def wrap_server_call(self, request: ServerRequest, call) -> Any: + self.calls.append(('wrap_enter', request)) + try: + return await call() + finally: + self.calls.append(('wrap_exit', request)) + + def wrap_names(self) -> list[str]: + """Hook order with the execution and task hooks filtered out.""" + return [n for n in self.names() if n in WRAP_HOOKS] + async def before_execution(self, request_context: RequestContext) -> None: self.calls.append(('before_execution', request_context)) @@ -283,18 +315,26 @@ async def test_send_message_runs_all_server_hooks(): assert names[0] == 'before_handler_run' assert names.index('before_execution') < names.index('on_execution_event') + # One wrap around the call, inside the before and after hooks. + assert recorder.wrap_names() == [ + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + ] + @pytest.mark.asyncio async def test_streaming_reports_each_event_and_a_final_call(): recorder = Recorder() handler = make_handler(recorder) - streamed = [ - event - async for event in handler.on_message_send_stream( - send_request(), ServerCallContext() - ) - ] + streamed = [] + async for event in handler.on_message_send_stream( + send_request(), ServerCallContext() + ): + streamed.append(event) + recorder.calls.append(('consumer', None)) responses = recorder.hooks('after_handler_run') assert [r.payload for r in responses[:-1]] == streamed @@ -306,6 +346,15 @@ async def test_streaming_reports_each_event_and_a_final_call(): assert final.payload is None assert final.error is None + # Every step is wrapped separately and closes before the consumer sees + # the event: one step per event, one for the end of the stream, one for + # the close. + expected = ['before_handler_run'] + for _ in streamed: + expected += ['wrap_enter', 'wrap_exit', 'after_handler_run', 'consumer'] + expected += ['wrap_enter', 'wrap_exit'] * 2 + ['after_handler_run'] + assert recorder.wrap_names() == expected + @pytest.mark.asyncio async def test_stream_closed_early_still_gets_final_call(): @@ -319,6 +368,17 @@ async def test_stream_closed_early_still_gets_final_call(): final = recorder.hooks('after_handler_run')[-1] assert final.is_final assert final.error is None + # Abandoning the stream leaves no wrap open: one step for the consumed + # event, one for the close. + assert recorder.wrap_names() == [ + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + ] @pytest.mark.asyncio @@ -335,6 +395,13 @@ async def test_handler_error_reaches_after_handler_run(): assert response.method == 'get_task' assert isinstance(response.error, TaskNotFoundError) assert response.is_final + # A failing handler still exits its wrap before the after hook runs. + assert recorder.wrap_names() == [ + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + ] @pytest.mark.asyncio @@ -358,6 +425,16 @@ async def test_stream_error_reaches_final_call(): final = recorder.hooks('after_handler_run')[-1] assert isinstance(final.error, TaskNotFoundError) + # The failure lands on the first step, so no event is ever reported: + # one wrap for that step, one for the close. + assert recorder.wrap_names() == [ + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + ] class BlockingTaskStore(InMemoryTaskStore): @@ -770,3 +847,70 @@ async def test_handler_plugins_do_not_reach_a_sender_with_its_own_manager(): assert received assert 'x-plugin' not in received[0].headers assert recorder.hooks('before_push_send') == [] + + +@pytest.mark.parametrize('streaming', [False, True]) +@pytest.mark.asyncio +async def test_wraps_nest_in_registration_order(streaming): + """Wraps nest in registration order; one without the hook adds no layer.""" + log: list[str] = [] + handler = DefaultRequestHandlerV2( + agent_executor=MessageAgent(), + task_store=InMemoryTaskStore(), + agent_card=CARD, + plugins=plugins.sequential( + wrapping('a', log), + # A plugin that does not override the hook adds no layer. + plugins.ServerPlugin(), + wrapping('b', log), + ), + ) + + if streaming: + async for _ in handler.on_message_send_stream( + send_request(), ServerCallContext() + ): + pass + else: + with pytest.raises(TaskNotFoundError): + await handler.on_get_task( + GetTaskRequest(id='missing'), ServerCallContext() + ) + + step = ['a-enter', 'b-enter', 'b-exit', 'a-exit'] + assert log[: len(step)] == step + assert len(log) == len(step) * (3 if streaming else 1) + + +@pytest.mark.asyncio +async def test_error_raised_inside_the_wrap_reaches_the_caller(): + """A plugin raising in its wrap skips the handler and fails the call.""" + + class Boom(plugins.ServerPlugin): + async def wrap_server_call(self, request, call): + raise RuntimeError('plugin bug') + + recorder = Recorder() + handler = DefaultRequestHandlerV2( + agent_executor=MessageAgent(), + task_store=InMemoryTaskStore(), + agent_card=CARD, + plugins=plugins.sequential(recorder, Boom()), + ) + + # The unknown id would raise TaskNotFoundError, so a RuntimeError proves + # the handler never ran. + with pytest.raises(RuntimeError): + await handler.on_get_task( + GetTaskRequest(id='missing'), ServerCallContext() + ) + + assert recorder.wrap_names() == [ + 'before_handler_run', + 'wrap_enter', + 'wrap_exit', + 'after_handler_run', + ] + assert isinstance( + recorder.hooks('after_handler_run')[-1].error, RuntimeError + ) From 07b209362795816ab97694d9400bf0f14ef660a2 Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Tue, 17 Nov 2026 13:24:34 +0000 Subject: [PATCH 4/7] refactor: wrap stream around aclosing() --- src/a2a/client/base_client.py | 11 +++++------ .../server/request_handlers/_plugin_hooks.py | 7 +++---- tests/client/test_base_client_plugins.py | 17 ++++++----------- .../test_default_request_handler_v2_plugins.py | 17 +++++++---------- 4 files changed, 21 insertions(+), 31 deletions(-) diff --git a/src/a2a/client/base_client.py b/src/a2a/client/base_client.py index c0f53d873..506691654 100644 --- a/src/a2a/client/base_client.py +++ b/src/a2a/client/base_client.py @@ -522,12 +522,13 @@ async def _execute_stream_with_interceptors( request = self._client_request(input_data, method, context) await plugins.before_client_request(request) - events = self._stream_through_interceptors( - request.payload, method, request.context, transport_call - ) error: BaseException | None = None try: - try: + async with aclosing( + self._stream_through_interceptors( + request.payload, method, request.context, transport_call + ) + ) as events: while True: # None marks the end of the stream, so StopAsyncIteration # never passes through plugin code. @@ -546,8 +547,6 @@ async def _execute_stream_with_interceptors( ) ) yield event - finally: - await plugins.wrap_client_call(request, events.aclose) except Exception as e: error = e raise diff --git a/src/a2a/server/request_handlers/_plugin_hooks.py b/src/a2a/server/request_handlers/_plugin_hooks.py index fb7d487a0..7acbd774d 100644 --- a/src/a2a/server/request_handlers/_plugin_hooks.py +++ b/src/a2a/server/request_handlers/_plugin_hooks.py @@ -68,10 +68,11 @@ async def stream_wrapper( method, params, context, self.agent_card ) await plugins.before_handler_run(request) - events = func(self, params, context, *args, **kwargs) error: BaseException | None = None try: - try: + async with aclosing( + func(self, params, context, *args, **kwargs) + ) as events: while True: # None marks the end of the stream, so # StopAsyncIteration never passes through plugin @@ -91,8 +92,6 @@ async def stream_wrapper( ) ) yield event - finally: - await plugins.wrap_server_call(request, events.aclose) except (Exception, asyncio.CancelledError) as e: error = e raise diff --git a/tests/client/test_base_client_plugins.py b/tests/client/test_base_client_plugins.py index 48a8e2347..aad0961dc 100644 --- a/tests/client/test_base_client_plugins.py +++ b/tests/client/test_base_client_plugins.py @@ -212,8 +212,8 @@ async def stream(request, *, context=None): assert responses[-1].payload is None assert responses[-1].error is None # Every step is wrapped separately, and each wrap closes before the - # consumer sees the event: one step per event, one for the end of the - # stream, one for the close. + # consumer sees the event: one step per event, plus one for the end of + # the stream. Closing the stream is not wrapped. assert recorder.names() == [ 'before_client_request', 'wrap_enter', @@ -226,8 +226,6 @@ async def stream(request, *, context=None): 'consumer', 'wrap_enter', 'wrap_exit', - 'wrap_enter', - 'wrap_exit', 'after_client_request', ] @@ -248,14 +246,12 @@ async def stream(request, *, context=None): assert recorder.hooks('after_client_request')[-1].is_final # Abandoning the stream leaves no wrap open: one step for the consumed - # event, one for the close. + # event, and the close itself is not wrapped. assert recorder.names() == [ 'before_client_request', 'wrap_enter', 'wrap_exit', 'after_client_request', - 'wrap_enter', - 'wrap_exit', 'after_client_request', ] @@ -291,7 +287,7 @@ async def failing(request, *, context=None): assert isinstance( recorder.hooks('after_client_request')[-1].error, ConnectionError ) - # The step that raises exits its wrap, as does the close. + # The step that raises still exits its wrap before the final hook. assert recorder.names() == [ 'before_client_request', 'wrap_enter', @@ -299,8 +295,6 @@ async def failing(request, *, context=None): 'after_client_request', 'wrap_enter', 'wrap_exit', - 'wrap_enter', - 'wrap_exit', 'after_client_request', ] @@ -505,7 +499,8 @@ async def stream(request, *, context=None): step = ['a-enter', 'b-enter', 'b-exit', 'a-exit'] assert log[: len(step)] == step - assert len(log) == len(step) * (3 if streaming else 1) + # A one-event stream is two steps: the event and the end of the stream. + assert len(log) == len(step) * (2 if streaming else 1) @pytest.mark.asyncio diff --git a/tests/server/request_handlers/test_default_request_handler_v2_plugins.py b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py index ea289eb4a..cdb4ca2c3 100644 --- a/tests/server/request_handlers/test_default_request_handler_v2_plugins.py +++ b/tests/server/request_handlers/test_default_request_handler_v2_plugins.py @@ -347,12 +347,12 @@ async def test_streaming_reports_each_event_and_a_final_call(): assert final.error is None # Every step is wrapped separately and closes before the consumer sees - # the event: one step per event, one for the end of the stream, one for - # the close. + # the event: one step per event, plus one for the end of the stream. + # Closing the stream is not wrapped. expected = ['before_handler_run'] for _ in streamed: expected += ['wrap_enter', 'wrap_exit', 'after_handler_run', 'consumer'] - expected += ['wrap_enter', 'wrap_exit'] * 2 + ['after_handler_run'] + expected += ['wrap_enter', 'wrap_exit', 'after_handler_run'] assert recorder.wrap_names() == expected @@ -369,14 +369,12 @@ async def test_stream_closed_early_still_gets_final_call(): assert final.is_final assert final.error is None # Abandoning the stream leaves no wrap open: one step for the consumed - # event, one for the close. + # event, and the close itself is not wrapped. assert recorder.wrap_names() == [ 'before_handler_run', 'wrap_enter', 'wrap_exit', 'after_handler_run', - 'wrap_enter', - 'wrap_exit', 'after_handler_run', ] @@ -426,13 +424,11 @@ async def test_stream_error_reaches_final_call(): final = recorder.hooks('after_handler_run')[-1] assert isinstance(final.error, TaskNotFoundError) # The failure lands on the first step, so no event is ever reported: - # one wrap for that step, one for the close. + # one wrap for that step, and the close is not wrapped. assert recorder.wrap_names() == [ 'before_handler_run', 'wrap_enter', 'wrap_exit', - 'wrap_enter', - 'wrap_exit', 'after_handler_run', ] @@ -879,7 +875,8 @@ async def test_wraps_nest_in_registration_order(streaming): step = ['a-enter', 'b-enter', 'b-exit', 'a-exit'] assert log[: len(step)] == step - assert len(log) == len(step) * (3 if streaming else 1) + # A one-event stream is two steps: the event and the end of the stream. + assert len(log) == len(step) * (2 if streaming else 1) @pytest.mark.asyncio From d9cbb0b6721a94d6573333fdc626a9c7f4894367 Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Tue, 17 Nov 2026 13:36:41 +0000 Subject: [PATCH 5/7] fix: add END marker to stream --- src/a2a/client/base_client.py | 19 ++++++++++++++---- .../server/request_handlers/_plugin_hooks.py | 20 ++++++++++++++----- 2 files changed, 30 insertions(+), 9 deletions(-) diff --git a/src/a2a/client/base_client.py b/src/a2a/client/base_client.py index 506691654..2e8bbb79b 100644 --- a/src/a2a/client/base_client.py +++ b/src/a2a/client/base_client.py @@ -34,6 +34,17 @@ ) +class _StreamEnd: + """Marker for a stream with no more events. + + Used instead of ``None`` because an interceptor can set a stream event to + ``None``, which would otherwise look like the end of the stream. + """ + + +_END = _StreamEnd() + + class BaseClient(Client): """Base implementation of the A2A client, containing transport-independent logic. @@ -530,12 +541,12 @@ async def _execute_stream_with_interceptors( ) ) as events: while True: - # None marks the end of the stream, so StopAsyncIteration - # never passes through plugin code. + # A marker ends the loop, so StopAsyncIteration never + # passes through plugin code. event = await plugins.wrap_client_call( - request, lambda: anext(events, None) + request, lambda: anext(events, _END) ) - if event is None: + if isinstance(event, _StreamEnd): break await plugins.after_client_request( ClientResponse( diff --git a/src/a2a/server/request_handlers/_plugin_hooks.py b/src/a2a/server/request_handlers/_plugin_hooks.py index 7acbd774d..1e78bdafa 100644 --- a/src/a2a/server/request_handlers/_plugin_hooks.py +++ b/src/a2a/server/request_handlers/_plugin_hooks.py @@ -33,6 +33,17 @@ def agent_card(self) -> AgentCard: ... _F = TypeVar('_F', bound='Callable[..., Any]') +class _StreamEnd: + """Marker for a stream with no more events. + + Used instead of ``None`` so that no handler value can be mistaken for + the end of the stream. + """ + + +_END = _StreamEnd() + + def server_plugin_hooks(method: str) -> Callable[[_F], _F]: """Runs `before_handler_run` / `after_handler_run` around a handler method. @@ -74,13 +85,12 @@ async def stream_wrapper( func(self, params, context, *args, **kwargs) ) as events: while True: - # None marks the end of the stream, so - # StopAsyncIteration never passes through plugin - # code. + # A marker ends the loop, so StopAsyncIteration + # never passes through plugin code. event = await plugins.wrap_server_call( - request, lambda: anext(events, None) + request, lambda: anext(events, _END) ) - if event is None: + if isinstance(event, _StreamEnd): break await plugins.after_handler_run( ServerResponse( From 2c159e18836061ad96775b58a7840aa5e02e30ea Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Wed, 18 Nov 2026 10:07:04 +0000 Subject: [PATCH 6/7] test: add test to cover wrappers --- tests/plugins/test_manager.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/plugins/test_manager.py b/tests/plugins/test_manager.py index db0e479f9..cc23d6570 100644 --- a/tests/plugins/test_manager.py +++ b/tests/plugins/test_manager.py @@ -345,3 +345,25 @@ def test_global_registry(): def test_set_global_requires_manager(): with pytest.raises(TypeError, match='sequential'): plugins.set_global(Recorder('a', [])) # type: ignore[arg-type] + + +@pytest.mark.parametrize( + ('plugin', 'hook'), + [ + (ClientPlugin(), 'wrap_client_call'), + (ServerPlugin(), 'wrap_server_call'), + ], +) +@pytest.mark.asyncio +async def test_wrap_defaults_run_the_call_unchanged(plugin, hook): + """The base wrap hooks call through, for subclasses that use super(). + + The manager skips plugins that do not override the hook, so these + bodies only run through an explicit super() call. + """ + sentinel = object() + + async def call(): + return sentinel + + assert await getattr(plugin, hook)(None, call) is sentinel From 318c02d1e13a7616f588d1402a85305860d858e1 Mon Sep 17 00:00:00 2001 From: Iwaniukooo11 Date: Wed, 18 Nov 2026 10:21:05 +0000 Subject: [PATCH 7/7] fix comments --- tests/client/test_base_client_plugins.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/tests/client/test_base_client_plugins.py b/tests/client/test_base_client_plugins.py index aad0961dc..77aa69185 100644 --- a/tests/client/test_base_client_plugins.py +++ b/tests/client/test_base_client_plugins.py @@ -211,9 +211,6 @@ async def stream(request, *, context=None): assert responses[-1].is_final assert responses[-1].payload is None assert responses[-1].error is None - # Every step is wrapped separately, and each wrap closes before the - # consumer sees the event: one step per event, plus one for the end of - # the stream. Closing the stream is not wrapped. assert recorder.names() == [ 'before_client_request', 'wrap_enter', @@ -245,8 +242,6 @@ async def stream(request, *, context=None): await events.aclose() assert recorder.hooks('after_client_request')[-1].is_final - # Abandoning the stream leaves no wrap open: one step for the consumed - # event, and the close itself is not wrapped. assert recorder.names() == [ 'before_client_request', 'wrap_enter', @@ -267,7 +262,6 @@ async def test_transport_errors_reach_after_client_request(): (response,) = recorder.hooks('after_client_request') assert isinstance(response.error, ConnectionError) - # A failing call still exits its wrap before the after hook runs. assert recorder.names() == [ 'before_client_request', 'wrap_enter', @@ -287,7 +281,6 @@ async def failing(request, *, context=None): assert isinstance( recorder.hooks('after_client_request')[-1].error, ConnectionError ) - # The step that raises still exits its wrap before the final hook. assert recorder.names() == [ 'before_client_request', 'wrap_enter',