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 2d39b7d21..9768be1ea 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 @@ -97,11 +98,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, @@ -245,11 +249,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, @@ -364,26 +371,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 9d2b6ec2b..ac79f0664 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 @@ -142,14 +143,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, @@ -327,13 +331,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, @@ -409,19 +416,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/src/a2a/compat/v0_3/jsonrpc_transport.py b/src/a2a/compat/v0_3/jsonrpc_transport.py index ddeeb3f89..634ab8d08 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 @@ -138,11 +139,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, @@ -361,11 +365,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, @@ -438,56 +445,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 d48b83a5f..c9df9cc34 100644 --- a/src/a2a/compat/v0_3/rest_transport.py +++ b/src/a2a/compat/v0_3/rest_transport.py @@ -156,13 +156,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, @@ -323,12 +326,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 (an HTTP status error) cause = e.__cause__ @@ -343,8 +349,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 @@ -429,21 +438,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: 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 7ff18356f..d3035a25f 100644 --- a/tests/integration/test_stream_generator_cleanup.py +++ b/tests/integration/test_stream_generator_cleanup.py @@ -7,8 +7,11 @@ import asyncio import gc +import json -from typing import Any +from collections.abc import AsyncGenerator, AsyncIterator +from contextlib import asynccontextmanager +from typing import Any, cast from uuid import uuid4 import pytest @@ -16,6 +19,10 @@ 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.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 from a2a.server.events import EventQueue from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager @@ -30,13 +37,16 @@ Part, Role, SendMessageRequest, + StreamResponse, + SubscribeToTaskRequest, ) from a2a.utils import TransportProtocol from a2a.utils._httpx_compat import httpx_lib +from google.protobuf.json_format import MessageToDict from starlette.applications import Starlette -pytestmark = pytest.mark.httpx2 +pytestmark = [pytest.mark.timeout(10), pytest.mark.httpx2] class _MessageExecutor(AgentExecutor): @@ -134,3 +144,314 @@ async def test_stream_message_no_athrow(client: BaseClient) -> None: finally: loop.set_exception_handler(orig) await client.close() + + +class _OpenResponseStream(httpx_lib.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') + + +@asynccontextmanager +async def _streaming_client( + binding: str, + version: str, + monkeypatch: pytest.MonkeyPatch, + *, + tenant: str = '', + plugins_enabled: bool = False, + message_reply: bool = False, + reject_response: bool = False, + subscribe_fallback: bool = False, +) -> AsyncIterator[ + tuple[BaseClient, httpx_lib.AsyncClient, _OpenResponseStream] +]: + legacy = version == '0.3' + task = { + 'id': 'task', + 'contextId': 'context', + 'status': {'state': 'working' if legacy else 'TASK_STATE_WORKING'}, + } + 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_lib.Request) -> httpx_lib.Response: + methods.append(request.method) + if subscribe_fallback and request.method == 'POST': + return httpx_lib.Response(405) + data = event + if binding == 'JSONRPC': + 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_lib.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=version, + tenant=tenant, + ) + ], + ) + async with httpx_lib.AsyncClient( + transport=httpx_lib.MockTransport(respond) + ) as http: + client = ClientFactory( + ClientConfig( + httpx_client=http, supported_protocol_bindings=[binding] + ) + ).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')), + ) + async with _bounded_events(events): + assert ( + await asyncio.wait_for(anext(events), timeout=2) + ).task.id == 'task' + assert response.closed