From 43443d14c5ab8b9bc9d7aaf31263351f071afca2 Mon Sep 17 00:00:00 2001
From: Mark Stuart <markstuart@openai.com>
Date: Sat, 26 Sep 2026 23:46:23 +0000
Subject: [PATCH] test: verify omitted and explicit Responses WebSocket
 preconnect (#3968)

The Responses WebSocket preconnect omission fix needs regression
coverage across sync and async clients. Add one test file exercising
both paths against real local WebSocket upgrades, so an absent optional
query field cannot silently turn into an explicit false value. It also
covers false and true when supplied.

The file is tests only, with no production, dependency or generated-code
changes.

Validation on the committed test bytes:
- 319/319 selected Responses and WebSocket tests under Pydantic v2.
- 319/319 under Pydantic v1.
- 2/2 existing live selectors passed.
- Changed-file lint and typing checks passed.
---
 .../responses/test_websocket_preconnect.py    | 98 +++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 tests/lib/responses/test_websocket_preconnect.py

diff --git a/tests/lib/responses/test_websocket_preconnect.py b/tests/lib/responses/test_websocket_preconnect.py
new file mode 100644
index 0000000000..9205d8544c
--- /dev/null
+++ b/tests/lib/responses/test_websocket_preconnect.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+import httpx2
+import pytest
+from websockets.sync.server import ServerConnection
+
+from openai import OpenAI, AsyncOpenAI, omit, not_given
+from openai.resources.beta.responses.responses import (
+    ResponsesConnectionManager as BetaResponsesConnectionManager,
+    AsyncResponsesConnectionManager as BetaAsyncResponsesConnectionManager,
+)
+from openai.types.beta.beta_responses_client_event import ResponseCreate as BetaResponseCreate
+from openai.types.responses.responses_client_event import ResponseCreate
+from openai.types.beta.beta_response_completed_event import BetaResponseCompletedEvent
+from openai.types.responses.response_completed_event import ResponseCompletedEvent
+
+from .test_websocket_session import script_server, response_event
+
+
+@pytest.fixture(autouse=True)
+def bypass_proxy(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("NO_PROXY", "127.0.0.1")
+    monkeypatch.setenv("no_proxy", "127.0.0.1")
+
+
+@pytest.mark.parametrize("mode", ["sync", "async"])
+@pytest.mark.parametrize("beta", [False, True], ids=["public", "beta"])
+async def test_preopen_sends_normalize_omissions_without_losing_values_or_order(mode: str, beta: bool) -> None:
+    received: list[dict[str, Any]] = []
+    handled: list[str] = []
+
+    def script(socket: ServerConnection) -> None:
+        for _ in range(2):
+            received.append(json.loads(socket.recv(timeout=5)))
+        socket.send(json.dumps(response_event("completed", id="resp_queued")))
+        socket.close()
+
+    def handle_completed(event: ResponseCompletedEvent | BetaResponseCompletedEvent) -> None:
+        handled.append(event.response.id)
+
+    first: dict[str, Any] = {
+        "type": "response.create",
+        "model": "gpt-4o-mini",
+        "instructions": omit,
+        "previous_response_id": not_given,
+        "input": [],
+        "tools": [],
+        "store": False,
+        "metadata": {},
+        "tool_choice": None,
+        "future_option": {"enabled": False, "value": None, "empty": []},
+    }
+    with script_server(script) as url:
+        if mode == "sync":
+            with OpenAI(
+                api_key="fake-preconnect-key", base_url=url, http_client=httpx2.Client(trust_env=False)
+            ) as client:
+                manager = client.beta.responses.connect() if beta else client.responses.connect()
+                manager.send(cast(Any, first))
+                if isinstance(manager, BetaResponsesConnectionManager):
+                    manager.send(BetaResponseCreate(type="response.create", model="gpt-4o-mini", input="second"))
+                else:
+                    manager.send(ResponseCreate(type="response.create", model="gpt-4o-mini", input="second"))
+                manager.on("response.completed", handle_completed)
+                with manager as connection:
+                    connection.dispatch_events()
+        else:
+            async with AsyncOpenAI(
+                api_key="fake-preconnect-key", base_url=url, http_client=httpx2.AsyncClient(trust_env=False)
+            ) as async_client:
+                # Queueing is synchronous even when opening/reading is async.
+                async_manager = async_client.beta.responses.connect() if beta else async_client.responses.connect()
+                async_manager.send(cast(Any, first))
+                if isinstance(async_manager, BetaAsyncResponsesConnectionManager):
+                    async_manager.send(BetaResponseCreate(type="response.create", model="gpt-4o-mini", input="second"))
+                else:
+                    async_manager.send(ResponseCreate(type="response.create", model="gpt-4o-mini", input="second"))
+                async_manager.on("response.completed", handle_completed)
+                async with async_manager as async_connection:
+                    await async_connection.dispatch_events()
+
+    assert received == [
+        {
+            "type": "response.create",
+            "model": "gpt-4o-mini",
+            "input": [],
+            "tools": [],
+            "store": False,
+            "metadata": {},
+            "tool_choice": None,
+            "future_option": {"enabled": False, "value": None, "empty": []},
+        },
+        {"type": "response.create", "model": "gpt-4o-mini", "input": "second"},
+    ]
+    assert handled == ["resp_queued"]