44import copy
55import json
66import logging
7+ from contextlib import nullcontext
78from dataclasses import asdict , fields , replace
89from types import SimpleNamespace
910from typing import Any , cast
@@ -908,7 +909,10 @@ def __init__(self):
908909
909910@pytest .mark .allow_call_model_methods
910911@pytest .mark .asyncio
911- async def test_stream_response_ignores_streaming_context_exit_failure_after_terminal_event ():
912+ @pytest .mark .parametrize ("event_type" , ["response.completed" , "error" ])
913+ async def test_stream_response_ignores_streaming_context_exit_failure_after_terminal_event (
914+ event_type ,
915+ ):
912916 class DummyHTTPStream :
913917 def __init__ (self ):
914918 self ._yielded = False
@@ -920,6 +924,14 @@ async def __anext__(self):
920924 if self ._yielded :
921925 raise StopAsyncIteration
922926 self ._yielded = True
927+ if event_type == "error" :
928+ return ResponseErrorEvent (
929+ type = "error" ,
930+ code = "server_error" ,
931+ message = "synthetic provider failure" ,
932+ param = None ,
933+ sequence_number = 0 ,
934+ )
923935 return ResponseCompletedEvent (
924936 type = "response.completed" ,
925937 response = get_response_obj ([], response_id = "resp-stream-request-id" ),
@@ -958,23 +970,123 @@ def __init__(self):
958970
959971 model = OpenAIResponsesModel (model = "gpt-4" , openai_client = DummyResponsesClient ()) # type: ignore[arg-type]
960972
961- events : list [ResponseCompletedEvent ] = []
962- async for event in model .stream_response (
963- system_instructions = None ,
964- input = "hi" ,
965- model_settings = ModelSettings (),
966- tools = [],
967- output_schema = None ,
968- handoffs = [],
969- tracing = ModelTracing .DISABLED ,
970- ):
971- assert isinstance (event , ResponseCompletedEvent )
972- events .append (event )
973+ events = []
974+ expected_error = (
975+ pytest .raises (ModelBehaviorError , match = "synthetic provider failure" )
976+ if event_type == "error"
977+ else nullcontext ()
978+ )
979+ with expected_error :
980+ async for event in model .stream_response (
981+ system_instructions = None ,
982+ input = "hi" ,
983+ model_settings = ModelSettings (),
984+ tools = [],
985+ output_schema = None ,
986+ handoffs = [],
987+ tracing = ModelTracing .DISABLED ,
988+ ):
989+ events .append (event )
973990
974- assert len ( events ) == 1
991+ assert [ event . type for event in events ] == [ event_type ]
975992 assert aexit_calls == [(None , None , None )]
976993
977994
995+ @pytest .mark .asyncio
996+ async def test_response_stream_preserves_error_event_when_cleanup_fails () -> None :
997+ event = ResponseErrorEvent (
998+ type = "error" ,
999+ code = "server_error" ,
1000+ message = "synthetic provider failure" ,
1001+ param = None ,
1002+ sequence_number = 0 ,
1003+ )
1004+ cleanup_calls = 0
1005+
1006+ async def events ():
1007+ yield event
1008+
1009+ async def cleanup ():
1010+ nonlocal cleanup_calls
1011+ cleanup_calls += 1
1012+ raise RuntimeError ("transport close failed" )
1013+
1014+ stream = _ResponseStreamWithRequestId (events (), request_id = None , cleanup = cleanup )
1015+ assert [item async for item in stream ] == [event ]
1016+ assert cleanup_calls == 1
1017+
1018+
1019+ @pytest .mark .allow_call_model_methods
1020+ @pytest .mark .asyncio
1021+ @pytest .mark .parametrize ("event_type" , ["error" , "response.failed" , "response.incomplete" , None ])
1022+ async def test_stream_response_preserves_terminal_failure_when_http_close_fails (
1023+ event_type : str | None ,
1024+ ) -> None :
1025+ # Exercise real SSE parsing and transport teardown, which a model fake would bypass.
1026+ close_calls = 0
1027+ if event_type == "error" :
1028+ payload = ResponseErrorEvent (
1029+ type = "error" ,
1030+ code = "server_error" ,
1031+ message = "synthetic provider failure" ,
1032+ param = None ,
1033+ sequence_number = 0 ,
1034+ ).model_dump ()
1035+ expected_message = "code=server_error; message=synthetic provider failure"
1036+ elif event_type is not None :
1037+ status = event_type .removeprefix ("response." )
1038+ payload = {
1039+ "type" : event_type ,
1040+ "sequence_number" : 0 ,
1041+ "response" : _response_with_terminal_status (status ).model_dump (),
1042+ }
1043+ expected_message = f"status={ status } "
1044+ else :
1045+ payload = None
1046+ expected_message = "transport close failed"
1047+
1048+ class FailingCloseStream (httpx2 .AsyncByteStream ):
1049+ async def __aiter__ (self ):
1050+ if payload is not None :
1051+ yield f"event: { event_type } \n data: { json .dumps (payload )} \n \n " .encode ()
1052+ yield b"data: [DONE]\n \n "
1053+
1054+ async def aclose (self ):
1055+ nonlocal close_calls
1056+ close_calls += 1
1057+ raise RuntimeError ("transport close failed" )
1058+
1059+ async def handler (request : httpx2 .Request ) -> httpx2 .Response :
1060+ return httpx2 .Response (
1061+ 200 ,
1062+ headers = {"content-type" : "text/event-stream" },
1063+ stream = FailingCloseStream (),
1064+ request = request ,
1065+ )
1066+
1067+ events = []
1068+ async with httpx2 .AsyncClient (transport = httpx2 .MockTransport (handler )) as http_client :
1069+ model = OpenAIResponsesModel (
1070+ model = "gpt-4" ,
1071+ openai_client = AsyncOpenAI (api_key = "test-key" , http_client = http_client ),
1072+ )
1073+ expected_exception = ModelBehaviorError if event_type is not None else RuntimeError
1074+ with pytest .raises (expected_exception , match = expected_message ):
1075+ async for event in model .stream_response (
1076+ system_instructions = None ,
1077+ input = "hi" ,
1078+ model_settings = ModelSettings (),
1079+ tools = [],
1080+ output_schema = None ,
1081+ handoffs = [],
1082+ tracing = ModelTracing .DISABLED ,
1083+ ):
1084+ events .append (event )
1085+
1086+ assert [event .type for event in events ] == ([event_type ] if event_type is not None else [])
1087+ assert close_calls == 1
1088+
1089+
9781090@pytest .mark .allow_call_model_methods
9791091@pytest .mark .asyncio
9801092async def test_stream_response_close_closes_inner_http_stream_with_async_close (monkeypatch ):
0 commit comments