|
18 | 18 | import agents._debug as _debug |
19 | 19 | from agents import trace |
20 | 20 | from agents.exceptions import UserError |
21 | | -from tests.testing_processor import fetch_span_errors |
| 21 | +from tests.testing_processor import fetch_events, fetch_ordered_spans, fetch_span_errors |
22 | 22 |
|
23 | 23 | try: |
| 24 | + from websockets.asyncio.server import ServerConnection, serve |
| 25 | + |
24 | 26 | from agents.voice import ( |
25 | 27 | AudioInput, |
26 | 28 | OpenAISTTModel, |
|
44 | 46 | # ===== Helpers ===== |
45 | 47 |
|
46 | 48 |
|
| 49 | +@pytest.mark.asyncio |
| 50 | +@pytest.mark.parametrize("tracing_disabled", [False, True]) |
| 51 | +async def test_close_during_setup_finishes_transcription_consumer( |
| 52 | + tracing_disabled: bool, |
| 53 | +) -> None: |
| 54 | + # A real socket controls the setup boundary without replacing SDK lifecycle tasks. |
| 55 | + setup_reached = asyncio.Event() |
| 56 | + socket_closed = asyncio.Event() |
| 57 | + |
| 58 | + async def handle_connection(socket: ServerConnection) -> None: |
| 59 | + try: |
| 60 | + await socket.send(json.dumps({"type": "session.created"})) |
| 61 | + update = json.loads(await socket.recv()) |
| 62 | + assert update["type"] == "session.update" |
| 63 | + setup_reached.set() |
| 64 | + await socket.wait_closed() |
| 65 | + finally: |
| 66 | + socket_closed.set() |
| 67 | + |
| 68 | + async with serve(handle_connection, "127.0.0.1", 0) as server: |
| 69 | + port = server.sockets[0].getsockname()[1] |
| 70 | + async with AsyncOpenAI( |
| 71 | + api_key="test-key", base_url=f"http://127.0.0.1:{port}/v1" |
| 72 | + ) as client: |
| 73 | + session = await OpenAISTTModel("gpt-4o-mini-transcribe", client).create_session( |
| 74 | + StreamedAudioInput(), STTModelSettings(), False, False |
| 75 | + ) |
| 76 | + assert isinstance(session, OpenAISTTTranscriptionSession) |
| 77 | + |
| 78 | + async def consume() -> list[str]: |
| 79 | + return [turn async for turn in session.transcribe_turns()] |
| 80 | + |
| 81 | + with trace("close during STT setup", disabled=tracing_disabled): |
| 82 | + consumer = asyncio.create_task(consume()) |
| 83 | + try: |
| 84 | + await asyncio.wait_for(setup_reached.wait(), 2) |
| 85 | + owned_tasks = [session._connection_task, session._listener_task] |
| 86 | + await asyncio.wait_for(session.close(), 2) |
| 87 | + await asyncio.wait_for(socket_closed.wait(), 2) |
| 88 | + assert all(task is not None and task.done() for task in owned_tasks) |
| 89 | + assert await asyncio.wait_for(asyncio.shield(consumer), 2) == [] |
| 90 | + |
| 91 | + # The iterator also closes in finally; repeated close must not add markers. |
| 92 | + await session.close() |
| 93 | + await session.close() |
| 94 | + assert session._output_queue.empty() |
| 95 | + await asyncio.wait_for(session._output_queue.join(), 2) |
| 96 | + finally: |
| 97 | + if not consumer.done(): |
| 98 | + consumer.cancel() |
| 99 | + await asyncio.gather(consumer, return_exceptions=True) |
| 100 | + await session.close() |
| 101 | + if not tracing_disabled: |
| 102 | + assert fetch_events().count("trace_start") == 1 |
| 103 | + assert fetch_events().count("trace_end") == 1 |
| 104 | + |
| 105 | + |
| 106 | +@pytest.mark.asyncio |
| 107 | +@pytest.mark.parametrize("outcome", ["close", "server_close", "error", "cancel"]) |
| 108 | +async def test_transcription_terminal_paths_after_setup(outcome: str) -> None: |
| 109 | + # Scripted STT bypasses the provider's socket and cannot exercise this close boundary. |
| 110 | + transcript_received = asyncio.Event() |
| 111 | + finish_server = asyncio.Event() |
| 112 | + socket_closed = asyncio.Event() |
| 113 | + |
| 114 | + async def handle_connection(socket: ServerConnection) -> None: |
| 115 | + try: |
| 116 | + await socket.send(json.dumps({"type": "session.created"})) |
| 117 | + assert json.loads(await socket.recv())["type"] == "session.update" |
| 118 | + await socket.send(json.dumps({"type": "session.updated"})) |
| 119 | + assert json.loads(await socket.recv())["type"] == "input_audio_buffer.append" |
| 120 | + await socket.send( |
| 121 | + json.dumps( |
| 122 | + { |
| 123 | + "type": "conversation.item.input_audio_transcription.completed", |
| 124 | + "transcript": "hello", |
| 125 | + } |
| 126 | + ) |
| 127 | + ) |
| 128 | + await finish_server.wait() |
| 129 | + if outcome == "error": |
| 130 | + await socket.send(json.dumps({"type": "error", "error": "test provider error"})) |
| 131 | + elif outcome == "server_close": |
| 132 | + await socket.close() |
| 133 | + await socket.wait_closed() |
| 134 | + finally: |
| 135 | + socket_closed.set() |
| 136 | + |
| 137 | + async with serve(handle_connection, "127.0.0.1", 0) as server: |
| 138 | + port = server.sockets[0].getsockname()[1] |
| 139 | + async with AsyncOpenAI( |
| 140 | + api_key="test-key", base_url=f"http://127.0.0.1:{port}/v1" |
| 141 | + ) as client: |
| 142 | + audio_input = StreamedAudioInput() |
| 143 | + await audio_input.add_audio(np.array([1, 2], dtype=np.int16)) |
| 144 | + session = await OpenAISTTModel("gpt-4o-mini-transcribe", client).create_session( |
| 145 | + audio_input, STTModelSettings(), False, False |
| 146 | + ) |
| 147 | + assert isinstance(session, OpenAISTTTranscriptionSession) |
| 148 | + transcripts: list[str] = [] |
| 149 | + |
| 150 | + async def consume() -> None: |
| 151 | + async for turn in session.transcribe_turns(): |
| 152 | + transcripts.append(turn) |
| 153 | + transcript_received.set() |
| 154 | + |
| 155 | + with trace("STT terminal paths"): |
| 156 | + consumer = asyncio.create_task(consume()) |
| 157 | + try: |
| 158 | + await asyncio.wait_for(transcript_received.wait(), 2) |
| 159 | + owned_tasks = [ |
| 160 | + session._connection_task, |
| 161 | + session._listener_task, |
| 162 | + session._process_events_task, |
| 163 | + session._stream_audio_task, |
| 164 | + ] |
| 165 | + finish_server.set() |
| 166 | + if outcome == "close": |
| 167 | + await asyncio.wait_for(session.close(), 2) |
| 168 | + elif outcome == "cancel": |
| 169 | + consumer.cancel() |
| 170 | + |
| 171 | + if outcome == "error": |
| 172 | + with pytest.raises( |
| 173 | + STTWebsocketConnectionError, match="Error parsing events" |
| 174 | + ): |
| 175 | + await asyncio.wait_for(asyncio.shield(consumer), 2) |
| 176 | + assert session._stored_exception is not None |
| 177 | + assert "test provider error" in str(session._stored_exception.__cause__) |
| 178 | + elif outcome == "cancel": |
| 179 | + with pytest.raises(asyncio.CancelledError): |
| 180 | + await asyncio.wait_for(asyncio.shield(consumer), 2) |
| 181 | + else: |
| 182 | + await asyncio.wait_for(asyncio.shield(consumer), 2) |
| 183 | + await session.close() |
| 184 | + assert session._output_queue.empty() |
| 185 | + await asyncio.wait_for(session._output_queue.join(), 2) |
| 186 | + |
| 187 | + assert transcripts == ["hello"] |
| 188 | + assert all(task is not None and task.done() for task in owned_tasks) |
| 189 | + await asyncio.wait_for(socket_closed.wait(), 2) |
| 190 | + finally: |
| 191 | + finish_server.set() |
| 192 | + if not consumer.done(): |
| 193 | + consumer.cancel() |
| 194 | + await asyncio.gather(consumer, return_exceptions=True) |
| 195 | + await session.close() |
| 196 | + |
| 197 | + events = fetch_events() |
| 198 | + assert events.count("span_start") == events.count("span_end") |
| 199 | + assert events[-1] == "trace_end" |
| 200 | + assert all(span.ended_at is not None for span in fetch_ordered_spans()) |
| 201 | + |
| 202 | + |
47 | 203 | def create_mock_websocket(messages: list[str]) -> AsyncMock: |
48 | 204 | """ |
49 | 205 | Creates a mock websocket (AsyncMock) that will return the provided incoming_messages |
|
0 commit comments