fix review comments

Author: seratch

src/agents/realtime/openai_realtime.py

@@ -492,6 +492,9 @@ async def _mark_response_done(self) -> None:
         await self._set_response_control("free")
 
     async def _release_response_waiters(self) -> None:
+        # Connection teardown means no response.done will arrive, so local
+        # response sequencing must be released explicitly.
+        self._ongoing_response = False
         await self._set_response_control("free")
 
     async def _send_response_create_when_idle(self) -> None:
@@ -701,7 +704,6 @@ async def _handle_conversation_item(
 
     async def close(self) -> None:
         """Close the session."""
-        await self._release_response_waiters()
         if self._websocket:
             await self._websocket.close()
             self._websocket = None
@@ -712,6 +714,7 @@ async def close(self) -> None:
             except asyncio.CancelledError:
                 pass
             self._websocket_task = None
+        await self._release_response_waiters()
 
     async def _cancel_response(self) -> None:
         async with self._response_control_condition:

tests/realtime/test_openai_realtime.py

@@ -812,6 +812,53 @@ async def fake_send_raw(event):
 
         assert payload_types == ["conversation.item.create", "response.create"]
 
+    @pytest.mark.asyncio
+    async def test_release_response_waiters_clears_active_response_state(self, model):
+        """Releasing waiters should also clear local active-response bookkeeping."""
+        await model._mark_response_created()
+
+        await model._release_response_waiters()
+
+        assert model._ongoing_response is False
+        assert model._response_control == "free"
+
+    @pytest.mark.asyncio
+    async def test_close_unblocks_waiting_response_create_after_active_response(self, model):
+        """Closing should unblock waiters without sending a new response.create."""
+        sent_types: list[str] = []
+        websocket_closed = False
+
+        async def send(payload: str) -> None:
+            nonlocal websocket_closed
+            if websocket_closed:
+                raise AssertionError("send should not run after close")
+            sent_types.append(json.loads(payload)["type"])
+
+        async def close() -> None:
+            nonlocal websocket_closed
+            websocket_closed = True
+
+        model._websocket = SimpleNamespace(send=send, close=close)
+        await model._mark_response_created()
+
+        task = asyncio.create_task(
+            model._send_user_input(RealtimeModelSendUserInput(user_input="hi"))
+        )
+        await asyncio.sleep(0)
+
+        assert sent_types == ["conversation.item.create"]
+        assert task.done() is False
+
+        await model.close()
+
+        with pytest.raises(AssertionError, match="Not connected"):
+            await asyncio.wait_for(task, timeout=1)
+
+        assert sent_types == ["conversation.item.create"]
+        assert model._ongoing_response is False
+        assert model._response_control == "free"
+        assert model._websocket is None
+
     @pytest.mark.asyncio
     async def test_tool_output_start_response_waits_for_response_done_before_response_create(
         self, model, monkeypatch