From 30c80b40f6ceb1d6874bfd34a750ab0ae1ecb685 Mon Sep 17 00:00:00 2001 From: Harshil <181649964+Harshil-1603@users.noreply.github.com> Date: Sun, 15 Nov 2026 08:14:30 +0530 Subject: [PATCH 1/2] fix(client): close HTTP responses when streams end early --- src/a2a/client/base_client.py | 36 ++-- src/a2a/client/transports/jsonrpc.py | 68 ++++---- src/a2a/client/transports/rest.py | 68 ++++---- src/a2a/client/transports/tenant_decorator.py | 17 +- .../test_stream_generator_cleanup.py | 155 +++++++++++++++++- 5 files changed, 264 insertions(+), 80 deletions(-) diff --git a/src/a2a/client/base_client.py b/src/a2a/client/base_client.py index fbcdb955e..ab7c93a66 100644 --- a/src/a2a/client/base_client.py +++ b/src/a2a/client/base_client.py @@ -144,20 +144,21 @@ def _apply_client_config(self, request: SendMessageRequest) -> None: async def _process_stream( self, - stream: AsyncIterator[StreamResponse], + stream: AsyncGenerator[StreamResponse], before_args: BeforeArgs, ) -> AsyncGenerator[StreamResponse, None]: - async for stream_response in stream: - after_args = AfterArgs( - result=stream_response, - method=before_args.method, - agent_card=self._card, - context=before_args.context, - ) - await self._intercept_after(after_args) - yield after_args.result - if after_args.result.HasField('message'): - return + async with aclosing(stream) as responses: + async for stream_response in responses: + after_args = AfterArgs( + result=stream_response, + method=before_args.method, + agent_card=self._card, + context=before_args.context, + ) + await self._intercept_after(after_args) + yield after_args.result + if after_args.result.HasField('message'): + return async def get_task( self, @@ -496,7 +497,7 @@ async def _execute_stream_with_interceptors( method: str, context: ClientCallContext | None, transport_call: Callable[ - [Any, ClientCallContext | None], AsyncIterator[StreamResponse] + [Any, ClientCallContext | None], AsyncGenerator[StreamResponse] ], ) -> AsyncGenerator[StreamResponse, None]: """Runs a streaming call through plugins, interceptors and the transport. @@ -551,7 +552,7 @@ async def _stream_through_interceptors( method: str, context: ClientCallContext | None, transport_call: Callable[ - [Any, ClientCallContext | None], AsyncIterator[StreamResponse] + [Any, ClientCallContext | None], AsyncGenerator[StreamResponse] ], ) -> AsyncGenerator[StreamResponse, None]: before_args = BeforeArgs( @@ -576,8 +577,11 @@ async def _stream_through_interceptors( stream = transport_call(before_args.input, before_args.context) - async for client_event in self._process_stream(stream, before_args): - yield client_event + async with aclosing( + self._process_stream(stream, before_args) + ) as events: + async for client_event in events: + yield client_event async def _intercept_before( self, diff --git a/src/a2a/client/transports/jsonrpc.py b/src/a2a/client/transports/jsonrpc.py index 8519b5c75..ce1a8b40c 100644 --- a/src/a2a/client/transports/jsonrpc.py +++ b/src/a2a/client/transports/jsonrpc.py @@ -2,6 +2,7 @@ import logging from collections.abc import AsyncGenerator +from contextlib import aclosing from typing import Any, NoReturn from uuid import uuid4 @@ -98,11 +99,14 @@ async def send_message_streaming( params=json_format.MessageToDict(request), _id=str(uuid4()), ) - async for event in self._send_stream_request( - dict(rpc_request.data), - context, - ): - yield event + async with aclosing( + self._send_stream_request( + dict(rpc_request.data), + context, + ) + ) as events: + async for event in events: + yield event async def get_task( self, @@ -246,11 +250,14 @@ async def subscribe( params=json_format.MessageToDict(request), _id=str(uuid4()), ) - async for event in self._send_stream_request( - dict(rpc_request.data), - context, - ): - yield event + async with aclosing( + self._send_stream_request( + dict(rpc_request.data), + context, + ) + ) as events: + async for event in events: + yield event async def get_extended_agent_card( self, @@ -365,26 +372,29 @@ async def _send_stream_request( ) -> AsyncGenerator[StreamResponse]: http_kwargs = get_http_args(context) - async for sse_data in send_http_stream_request( - self.httpx_client, - 'POST', - self.url, - None, - self._handle_sse_error, - json=rpc_request_payload, - **http_kwargs, - ): - try: - response_data = json.loads(sse_data) - except json.JSONDecodeError as e: - raise A2AClientError( - f'Invalid JSON-RPC response in SSE stream: {e}' - ) from e - response_data = self._check_jsonrpc_response(response_data) - response: StreamResponse = parse_lenient( - response_data['result'], StreamResponse() + async with aclosing( + send_http_stream_request( + self.httpx_client, + 'POST', + self.url, + None, + self._handle_sse_error, + json=rpc_request_payload, + **http_kwargs, ) - yield response + ) as data: + async for sse_data in data: + try: + response_data = json.loads(sse_data) + except json.JSONDecodeError as e: + raise A2AClientError( + f'Invalid JSON-RPC response in SSE stream: {e}' + ) from e + response_data = self._check_jsonrpc_response(response_data) + response: StreamResponse = parse_lenient( + response_data['result'], StreamResponse() + ) + yield response def _handle_sse_error(self, sse_data: str) -> NoReturn: """Handles SSE error events by parsing JSON-RPC error payload and raising the appropriate domain error.""" diff --git a/src/a2a/client/transports/rest.py b/src/a2a/client/transports/rest.py index 82a72f650..e7b5f25ee 100644 --- a/src/a2a/client/transports/rest.py +++ b/src/a2a/client/transports/rest.py @@ -2,6 +2,7 @@ import logging from collections.abc import AsyncGenerator +from contextlib import aclosing from typing import Any, NoReturn from urllib.parse import quote @@ -141,14 +142,17 @@ async def send_message_streaming( """Sends a streaming message request to the agent and yields responses as they arrive.""" payload = MessageToDict(request) - async for event in self._send_stream_request( - 'POST', - '/message:stream', - request.tenant, - context=context, - json=payload, - ): - yield event + async with aclosing( + self._send_stream_request( + 'POST', + '/message:stream', + request.tenant, + context=context, + json=payload, + ) + ) as events: + async for event in events: + yield event async def get_task( self, @@ -326,13 +330,16 @@ async def subscribe( context: ClientCallContext | None = None, ) -> AsyncGenerator[StreamResponse]: """Reconnects to get task updates.""" - async for event in self._send_stream_request( - 'POST', - f'/tasks/{_quote_id(request.id)}:subscribe', - request.tenant, - context=context, - ): - yield event + async with aclosing( + self._send_stream_request( + 'POST', + f'/tasks/{_quote_id(request.id)}:subscribe', + request.tenant, + context=context, + ) + ) as events: + async for event in events: + yield event async def get_extended_agent_card( self, @@ -408,19 +415,24 @@ async def _send_stream_request( path = self._get_path(target, tenant) http_kwargs = get_http_args(context) - async for sse_data in send_http_stream_request( - self.httpx_client, - method, - f'{self.url}{path}', - self._handle_http_error, - self._handle_sse_error, - json=json, - **http_kwargs, - ): - event: StreamResponse = parse_lenient(sse_data, StreamResponse()) - if event.WhichOneof('payload') is None: - self._raise_in_band_error(sse_data) - yield event + async with aclosing( + send_http_stream_request( + self.httpx_client, + method, + f'{self.url}{path}', + self._handle_http_error, + self._handle_sse_error, + json=json, + **http_kwargs, + ) + ) as data: + async for sse_data in data: + event: StreamResponse = parse_lenient( + sse_data, StreamResponse() + ) + if event.WhichOneof('payload') is None: + self._raise_in_band_error(sse_data) + yield event def _raise_in_band_error(self, sse_data: str) -> None: """Raises the error carried by a data event, if it carries one. diff --git a/src/a2a/client/transports/tenant_decorator.py b/src/a2a/client/transports/tenant_decorator.py index 93fbfe22b..add63b174 100644 --- a/src/a2a/client/transports/tenant_decorator.py +++ b/src/a2a/client/transports/tenant_decorator.py @@ -1,6 +1,7 @@ import copy from collections.abc import AsyncGenerator +from contextlib import aclosing from a2a.client.client import ClientCallContext from a2a.client.transports.base import ClientTransport @@ -59,10 +60,11 @@ async def send_message_streaming( """Sends a streaming message request to the agent and yields responses.""" request = copy.deepcopy(request) request.tenant = self._resolve_tenant(request.tenant) - async for event in self._base.send_message_streaming( - request, context=context - ): - yield event + async with aclosing( + self._base.send_message_streaming(request, context=context) + ) as events: + async for event in events: + yield event async def get_task( self, @@ -158,8 +160,11 @@ async def subscribe( """Reconnects to get task updates.""" request = copy.deepcopy(request) request.tenant = self._resolve_tenant(request.tenant) - async for event in self._base.subscribe(request, context=context): - yield event + async with aclosing( + self._base.subscribe(request, context=context) + ) as events: + async for event in events: + yield event async def get_extended_agent_card( self, diff --git a/tests/integration/test_stream_generator_cleanup.py b/tests/integration/test_stream_generator_cleanup.py index 3d9b1b171..39dff7c2c 100644 --- a/tests/integration/test_stream_generator_cleanup.py +++ b/tests/integration/test_stream_generator_cleanup.py @@ -7,8 +7,10 @@ import asyncio import gc +import json -from typing import Any +from collections.abc import AsyncGenerator, AsyncIterator +from typing import Any, cast from uuid import uuid4 import httpx @@ -17,6 +19,9 @@ from a2a.client.base_client import BaseClient from a2a.client.client import ClientConfig from a2a.client.client_factory import ClientFactory +from a2a.client.interceptors import AfterArgs, BeforeArgs, ClientCallInterceptor +from a2a.plugins.base import ClientPlugin +from a2a.plugins.manager import SequentialPluginManager from a2a.server.agent_execution import AgentExecutor, RequestContext from a2a.server.events import EventQueue from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager @@ -31,6 +36,8 @@ Part, Role, SendMessageRequest, + StreamResponse, + SubscribeToTaskRequest, ) from a2a.utils import TransportProtocol from starlette.applications import Starlette @@ -131,3 +138,149 @@ async def test_stream_message_no_athrow(client: BaseClient) -> None: finally: loop.set_exception_handler(orig) await client.close() + + +class _OpenResponseStream(httpx.AsyncByteStream): + def __init__(self, payload: bytes) -> None: + self.payload = payload + self.closed = False + self.waiting = asyncio.Event() + + async def __aiter__(self) -> AsyncIterator[bytes]: + yield self.payload + self.waiting.set() + await asyncio.Event().wait() + + async def aclose(self) -> None: + self.closed = True + + +class _RejectResponse(ClientCallInterceptor): + async def before(self, args: BeforeArgs) -> None: + pass + + async def after(self, args: AfterArgs) -> None: + raise RuntimeError('response rejected') + + +@pytest.mark.asyncio +@pytest.mark.parametrize('binding', ['JSONRPC', 'HTTP+JSON']) +@pytest.mark.parametrize('tenant', ['', 'tenant']) +@pytest.mark.parametrize('plugins_enabled', [False, True]) +@pytest.mark.parametrize( + 'ending', + [ + 'close_send', + 'close_subscribe', + 'message', + 'interceptor_error', + 'cancel_read', + ], +) +async def test_http_stream_is_closed_before_call_returns( + binding: str, + tenant: str, + plugins_enabled: bool, + ending: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + event: dict[str, Any] = { + 'task': { + 'id': 'task', + 'contextId': 'context', + 'status': {'state': 'TASK_STATE_WORKING'}, + } + } + if ending == 'message': + event = { + 'message': { + 'messageId': 'reply', + 'role': 'ROLE_AGENT', + 'parts': [{'text': 'done'}], + } + } + if binding == 'JSONRPC': + event = {'jsonrpc': '2.0', 'id': 'stream', 'result': event} + response_stream = _OpenResponseStream( + f'data: {json.dumps(event)}\n\n'.encode() + ) + + def respond(request: httpx.Request) -> httpx.Response: + if binding == 'JSONRPC': + payload = json.loads(request.content) + event['id'] = payload['id'] + response_stream.payload = f'data: {json.dumps(event)}\n\n'.encode() + return httpx.Response( + 200, + headers={'Content-Type': 'text/event-stream'}, + stream=response_stream, + ) + + plugins = SequentialPluginManager( + *([ClientPlugin()] if plugins_enabled else []) + ) + monkeypatch.setattr('a2a.client.base_client.get_global', lambda: plugins) + card = AgentCard( + name='streaming agent', + description='Test a live streaming response', + version='1', + default_input_modes=['text/plain'], + default_output_modes=['text/plain'], + capabilities=AgentCapabilities(streaming=True), + supported_interfaces=[ + AgentInterface( + url='http://agent', + protocol_binding=binding, + protocol_version='1.0', + tenant=tenant, + ) + ], + ) + async with httpx.AsyncClient( + transport=httpx.MockTransport(respond) + ) as http: + client = ClientFactory( + ClientConfig( + httpx_client=http, supported_protocol_bindings=[binding] + ) + ).create( + card, [_RejectResponse()] if ending == 'interceptor_error' else [] + ) + events = cast( + 'AsyncGenerator[StreamResponse]', + client.subscribe(SubscribeToTaskRequest(id='task')) + if ending == 'close_subscribe' + else client.send_message( + SendMessageRequest( + message=Message( + message_id='request', + role=Role.ROLE_USER, + parts=[Part(text='hi')], + ) + ) + ), + ) + try: + if ending == 'interceptor_error': + with pytest.raises(RuntimeError, match='response rejected'): + await anext(events) + elif ending == 'message': + replies = [event async for event in events] + assert len(replies) == 1 + assert replies[0].message.parts[0].text == 'done' + else: + first = await anext(events) + assert first.task.id == 'task' + assert not response_stream.closed + if ending == 'cancel_read': + read = asyncio.create_task(anext(events)) + await asyncio.wait_for(response_stream.waiting.wait(), 1) + read.cancel() + with pytest.raises(asyncio.CancelledError): + await read + else: + await events.aclose() + assert response_stream.closed + assert not http.is_closed + finally: + await events.aclose() From b4448c3226b9a7024580fbb80e54449dceaca80a Mon Sep 17 00:00:00 2001 From: Harshil <181649964+Harshil-1603@users.noreply.github.com> Date: Tue, 17 Nov 2026 03:05:20 +0530 Subject: [PATCH 2/2] fix(client): close legacy streams and clarify cleanup regressions Close each legacy HTTP forwarding generator, including REST subscription fallback. Split cleanup scenarios into independent bounded tests and share tenant/plugin setup across protocol versions. Assisted-by: OpenAI Codex --- src/a2a/compat/v0_3/jsonrpc_transport.py | 124 ++++--- src/a2a/compat/v0_3/rest_transport.py | 72 ++-- .../test_stream_generator_cleanup.py | 325 +++++++++++++----- 3 files changed, 357 insertions(+), 164 deletions(-) diff --git a/src/a2a/compat/v0_3/jsonrpc_transport.py b/src/a2a/compat/v0_3/jsonrpc_transport.py index 9e83168a1..d6b11ca2a 100644 --- a/src/a2a/compat/v0_3/jsonrpc_transport.py +++ b/src/a2a/compat/v0_3/jsonrpc_transport.py @@ -2,6 +2,7 @@ import logging from collections.abc import AsyncGenerator +from contextlib import aclosing from typing import Any, NoReturn from uuid import uuid4 @@ -139,11 +140,14 @@ async def send_message_streaming( ), _id=str(uuid4()), ) - async for event in self._send_stream_request( - dict(rpc_request.data), - context, - ): - yield event + async with aclosing( + self._send_stream_request( + dict(rpc_request.data), + context, + ) + ) as events: + async for event in events: + yield event async def get_task( self, @@ -362,11 +366,14 @@ async def subscribe( ), _id=str(uuid4()), ) - async for event in self._send_stream_request( - dict(rpc_request.data), - context, - ): - yield event + async with aclosing( + self._send_stream_request( + dict(rpc_request.data), + context, + ) + ) as events: + async for event in events: + yield event async def get_extended_agent_card( self, @@ -439,56 +446,59 @@ async def _send_stream_request( http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3 add_legacy_extension_header(http_kwargs['headers']) - async for sse_data in send_http_stream_request( - self.httpx_client, - 'POST', - self.url, - self._handle_http_error, - json=json_data, - **http_kwargs, - ): - data = json.loads(sse_data) - if 'error' in data: - raise self._create_jsonrpc_error(data['error']) - - result_dict = data.get('result', {}) - if not isinstance(result_dict, dict): - continue - - kind = result_dict.get('kind') - - if not kind: - if 'taskId' in result_dict and 'final' in result_dict: - kind = 'status-update' - elif 'messageId' in result_dict: - kind = 'message' - elif 'id' in result_dict: - kind = 'task' - - result: ( - types_v03.Task - | types_v03.Message - | types_v03.TaskStatusUpdateEvent - | types_v03.TaskArtifactUpdateEvent + async with aclosing( + send_http_stream_request( + self.httpx_client, + 'POST', + self.url, + self._handle_http_error, + json=json_data, + **http_kwargs, ) - if kind == 'task': - result = types_v03.Task.model_validate(result_dict) - elif kind == 'message': - result = types_v03.Message.model_validate(result_dict) - elif kind == 'status-update': - result = types_v03.TaskStatusUpdateEvent.model_validate( - result_dict + ) as events: + async for sse_data in events: + data = json.loads(sse_data) + if 'error' in data: + raise self._create_jsonrpc_error(data['error']) + + result_dict = data.get('result', {}) + if not isinstance(result_dict, dict): + continue + + kind = result_dict.get('kind') + + if not kind: + if 'taskId' in result_dict and 'final' in result_dict: + kind = 'status-update' + elif 'messageId' in result_dict: + kind = 'message' + elif 'id' in result_dict: + kind = 'task' + + result: ( + types_v03.Task + | types_v03.Message + | types_v03.TaskStatusUpdateEvent + | types_v03.TaskArtifactUpdateEvent ) - elif kind == 'artifact-update': - result = types_v03.TaskArtifactUpdateEvent.model_validate( - result_dict - ) - else: - continue + if kind == 'task': + result = types_v03.Task.model_validate(result_dict) + elif kind == 'message': + result = types_v03.Message.model_validate(result_dict) + elif kind == 'status-update': + result = types_v03.TaskStatusUpdateEvent.model_validate( + result_dict + ) + elif kind == 'artifact-update': + result = types_v03.TaskArtifactUpdateEvent.model_validate( + result_dict + ) + else: + continue - yield conversions.to_core_stream_response( - types_v03.SendStreamingMessageSuccessResponse(result=result) - ) + yield conversions.to_core_stream_response( + types_v03.SendStreamingMessageSuccessResponse(result=result) + ) async def _send_request( self, diff --git a/src/a2a/compat/v0_3/rest_transport.py b/src/a2a/compat/v0_3/rest_transport.py index 3f1e6b5c0..d120b91e1 100644 --- a/src/a2a/compat/v0_3/rest_transport.py +++ b/src/a2a/compat/v0_3/rest_transport.py @@ -148,13 +148,16 @@ async def send_message_streaming( metadata=proto_utils.ToProto.metadata(req_v03.params.metadata), ) - async for event in self._send_stream_request( - 'POST', - '/v1/message:stream', - context=context, - json=MessageToDict(req_proto), - ): - yield event + async with contextlib.aclosing( + self._send_stream_request( + 'POST', + '/v1/message:stream', + context=context, + json=MessageToDict(req_proto), + ) + ) as events: + async for event in events: + yield event async def get_task( self, @@ -315,12 +318,15 @@ async def subscribe( """ subscribe_method = self._subscribe_method_override or 'POST' try: - async for event in self._send_stream_request( - subscribe_method, - f'/v1/tasks/{_quote_id(request.id)}:subscribe', - context=context, - ): - yield event + async with contextlib.aclosing( + self._send_stream_request( + subscribe_method, + f'/v1/tasks/{_quote_id(request.id)}:subscribe', + context=context, + ) + ) as events: + async for event in events: + yield event except A2AClientError as e: # Check for 405 Method Not Allowed in the cause (httpx.HTTPStatusError) cause = e.__cause__ @@ -335,8 +341,11 @@ async def subscribe( raise else: self._subscribe_method_override = 'GET' - async for event in self.subscribe(request, context=context): - yield event + async with contextlib.aclosing( + self.subscribe(request, context=context) + ) as events: + async for event in events: + yield event else: raise @@ -421,21 +430,26 @@ async def _send_stream_request( http_kwargs['headers'][VERSION_HEADER.lower()] = PROTOCOL_VERSION_0_3 add_legacy_extension_header(http_kwargs['headers']) - async for sse_data in send_http_stream_request( - self.httpx_client, - method, - f'{self.url}{path}', - self._handle_http_error, - json=json, - **http_kwargs, - ): - event_proto = a2a_v0_3_pb2.StreamResponse() - Parse(sse_data, event_proto, ignore_unknown_fields=True) - yield conversions.to_core_stream_response( - types_v03.SendStreamingMessageSuccessResponse( - result=proto_utils.FromProto.stream_response(event_proto) - ) + async with contextlib.aclosing( + send_http_stream_request( + self.httpx_client, + method, + f'{self.url}{path}', + self._handle_http_error, + json=json, + **http_kwargs, ) + ) as events: + async for sse_data in events: + event_proto = a2a_v0_3_pb2.StreamResponse() + Parse(sse_data, event_proto, ignore_unknown_fields=True) + yield conversions.to_core_stream_response( + types_v03.SendStreamingMessageSuccessResponse( + result=proto_utils.FromProto.stream_response( + event_proto + ) + ) + ) async def _send_request(self, request: httpx.Request) -> dict[str, Any]: return await send_http_request( diff --git a/tests/integration/test_stream_generator_cleanup.py b/tests/integration/test_stream_generator_cleanup.py index 39dff7c2c..831ca3c77 100644 --- a/tests/integration/test_stream_generator_cleanup.py +++ b/tests/integration/test_stream_generator_cleanup.py @@ -10,6 +10,7 @@ import json from collections.abc import AsyncGenerator, AsyncIterator +from contextlib import asynccontextmanager from typing import Any, cast from uuid import uuid4 @@ -20,6 +21,7 @@ from a2a.client.client import ClientConfig from a2a.client.client_factory import ClientFactory from a2a.client.interceptors import AfterArgs, BeforeArgs, ClientCallInterceptor +from a2a.compat.v0_3 import proto_utils, types as types_v03 from a2a.plugins.base import ClientPlugin from a2a.plugins.manager import SequentialPluginManager from a2a.server.agent_execution import AgentExecutor, RequestContext @@ -40,9 +42,13 @@ SubscribeToTaskRequest, ) from a2a.utils import TransportProtocol +from google.protobuf.json_format import MessageToDict from starlette.applications import Starlette +pytestmark = pytest.mark.timeout(10) + + class _MessageExecutor(AgentExecutor): """Responds with a single Message event.""" @@ -163,53 +169,73 @@ async def after(self, args: AfterArgs) -> None: raise RuntimeError('response rejected') -@pytest.mark.asyncio -@pytest.mark.parametrize('binding', ['JSONRPC', 'HTTP+JSON']) -@pytest.mark.parametrize('tenant', ['', 'tenant']) -@pytest.mark.parametrize('plugins_enabled', [False, True]) -@pytest.mark.parametrize( - 'ending', - [ - 'close_send', - 'close_subscribe', - 'message', - 'interceptor_error', - 'cancel_read', - ], -) -async def test_http_stream_is_closed_before_call_returns( +@asynccontextmanager +async def _streaming_client( binding: str, - tenant: str, - plugins_enabled: bool, - ending: str, + version: str, monkeypatch: pytest.MonkeyPatch, -) -> None: - event: dict[str, Any] = { - 'task': { - 'id': 'task', - 'contextId': 'context', - 'status': {'state': 'TASK_STATE_WORKING'}, - } + *, + tenant: str = '', + plugins_enabled: bool = False, + message_reply: bool = False, + reject_response: bool = False, + subscribe_fallback: bool = False, +) -> AsyncIterator[tuple[BaseClient, httpx.AsyncClient, _OpenResponseStream]]: + legacy = version == '0.3' + task = { + 'id': 'task', + 'contextId': 'context', + 'status': {'state': 'working' if legacy else 'TASK_STATE_WORKING'}, } - if ending == 'message': - event = { - 'message': { - 'messageId': 'reply', - 'role': 'ROLE_AGENT', - 'parts': [{'text': 'done'}], - } - } - if binding == 'JSONRPC': - event = {'jsonrpc': '2.0', 'id': 'stream', 'result': event} - response_stream = _OpenResponseStream( - f'data: {json.dumps(event)}\n\n'.encode() + message = { + 'messageId': 'reply', + 'role': 'agent' if legacy else 'ROLE_AGENT', + 'parts': [{'kind': 'text', 'text': 'done'}] + if legacy + else [{'text': 'done'}], + } + event: dict[str, Any] = ( + {'message': message} if message_reply else {'task': task} ) + if legacy and binding == 'JSONRPC': + event = ( + dict(message, kind='message') + if message_reply + else dict(task, kind='task') + ) + elif legacy: + event = ( + { + 'message': MessageToDict( + proto_utils.ToProto.message( + types_v03.Message.model_validate(message) + ) + ) + } + if message_reply + else { + 'task': MessageToDict( + proto_utils.ToProto.task( + types_v03.Task.model_validate(dict(task, kind='task')) + ) + ) + } + ) + response_stream = _OpenResponseStream(b'') + methods: list[str] = [] def respond(request: httpx.Request) -> httpx.Response: + methods.append(request.method) + if subscribe_fallback and request.method == 'POST': + return httpx.Response(405) + data = event if binding == 'JSONRPC': - payload = json.loads(request.content) - event['id'] = payload['id'] - response_stream.payload = f'data: {json.dumps(event)}\n\n'.encode() + data = { + 'jsonrpc': '2.0', + 'id': json.loads(request.content)['id'], + 'result': event, + } + response_stream.payload = f'data: {json.dumps(data)}\n\n'.encode() return httpx.Response( 200, headers={'Content-Type': 'text/event-stream'}, @@ -231,7 +257,7 @@ def respond(request: httpx.Request) -> httpx.Response: AgentInterface( url='http://agent', protocol_binding=binding, - protocol_version='1.0', + protocol_version=version, tenant=tenant, ) ], @@ -243,44 +269,187 @@ def respond(request: httpx.Request) -> httpx.Response: ClientConfig( httpx_client=http, supported_protocol_bindings=[binding] ) - ).create( - card, [_RejectResponse()] if ending == 'interceptor_error' else [] + ).create(card, [_RejectResponse()] if reject_response else []) + yield client, http, response_stream + assert response_stream.closed + assert not http.is_closed + if subscribe_fallback: + assert methods == ['POST', 'GET'] + + +def _send(client: BaseClient) -> AsyncGenerator[StreamResponse]: + return cast( + 'AsyncGenerator[StreamResponse]', + client.send_message( + SendMessageRequest( + message=Message( + message_id='request', + role=Role.ROLE_USER, + parts=[Part(text='hi')], + ) + ) + ), + ) + + +@asynccontextmanager +async def _bounded_events( + events: AsyncGenerator[StreamResponse], +) -> AsyncIterator[AsyncGenerator[StreamResponse]]: + try: + yield events + finally: + await asyncio.wait_for(events.aclose(), timeout=2) + + +@pytest.fixture(params=['JSONRPC', 'HTTP+JSON']) +def binding(request: pytest.FixtureRequest) -> str: + return str(request.param) + + +@pytest.fixture(params=['1.0', '0.3']) +def version(request: pytest.FixtureRequest) -> str: + return str(request.param) + + +@pytest.mark.asyncio +async def test_http_send_stream_closes( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client(binding, version, monkeypatch) as ( + client, + _, + response, + ): + async with _bounded_events(_send(client)) as events: + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + assert not response.closed + assert response.closed + + +@pytest.mark.asyncio +async def test_http_subscribe_stream_closes( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client(binding, version, monkeypatch) as ( + client, + _, + response, + ): + events = cast( + 'AsyncGenerator[StreamResponse]', + client.subscribe(SubscribeToTaskRequest(id='task')), ) + async with _bounded_events(events): + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + assert not response.closed + assert response.closed + + +@pytest.mark.asyncio +async def test_http_message_reply_closes( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client( + binding, version, monkeypatch, message_reply=True + ) as (client, _, response): + async with _bounded_events(_send(client)) as events: + reply = await asyncio.wait_for(anext(events), timeout=2) + assert reply.message.parts[0].text == 'done' + with pytest.raises(StopAsyncIteration): + await asyncio.wait_for(anext(events), timeout=2) + assert response.closed + + +@pytest.mark.asyncio +async def test_http_interceptor_error_closes( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client( + binding, version, monkeypatch, reject_response=True + ) as (client, _, response): + async with _bounded_events(_send(client)) as events: + with pytest.raises(RuntimeError, match='response rejected'): + await asyncio.wait_for(anext(events), timeout=2) + assert response.closed + + +@pytest.mark.asyncio +async def test_http_cancelled_read_closes( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client(binding, version, monkeypatch) as ( + client, + _, + response, + ): + async with _bounded_events(_send(client)) as events: + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + read = asyncio.create_task(anext(events)) + try: + await asyncio.wait_for(response.waiting.wait(), timeout=2) + finally: + read.cancel() + with pytest.raises(asyncio.CancelledError): + await asyncio.wait_for(read, timeout=2) + assert response.closed + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ('tenant', 'plugins_enabled'), + [('tenant', False), ('', True), ('tenant', True)], +) +async def test_http_stream_closes_with_tenant_and_plugins( + binding: str, + version: str, + tenant: str, + plugins_enabled: bool, + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client( + binding, + version, + monkeypatch, + tenant=tenant, + plugins_enabled=plugins_enabled, + ) as (client, _, response): + async with _bounded_events(_send(client)) as events: + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + assert response.closed + + +@pytest.mark.asyncio +async def test_http_legacy_subscribe_fallback_closes( + monkeypatch: pytest.MonkeyPatch, +) -> None: + async with _streaming_client( + 'HTTP+JSON', '0.3', monkeypatch, subscribe_fallback=True + ) as (client, _, response): events = cast( 'AsyncGenerator[StreamResponse]', - client.subscribe(SubscribeToTaskRequest(id='task')) - if ending == 'close_subscribe' - else client.send_message( - SendMessageRequest( - message=Message( - message_id='request', - role=Role.ROLE_USER, - parts=[Part(text='hi')], - ) - ) - ), + client.subscribe(SubscribeToTaskRequest(id='task')), ) - try: - if ending == 'interceptor_error': - with pytest.raises(RuntimeError, match='response rejected'): - await anext(events) - elif ending == 'message': - replies = [event async for event in events] - assert len(replies) == 1 - assert replies[0].message.parts[0].text == 'done' - else: - first = await anext(events) - assert first.task.id == 'task' - assert not response_stream.closed - if ending == 'cancel_read': - read = asyncio.create_task(anext(events)) - await asyncio.wait_for(response_stream.waiting.wait(), 1) - read.cancel() - with pytest.raises(asyncio.CancelledError): - await read - else: - await events.aclose() - assert response_stream.closed - assert not http.is_closed - finally: - await events.aclose() + async with _bounded_events(events): + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + assert response.closed