Expected Responses WebSocket HTTP 426 fallback is logged at ERROR despite a successful turn

#!/usr/bin/env python3
import json
import os
import subprocess
import tempfile
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path


requests = []


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, _format, *_args):
        pass

    def do_GET(self):
        requests.append({
            "method": "GET",
            "path": self.path,
            "upgrade": self.headers.get("Upgrade"),
        })
        self.send_response(426, "Upgrade Required")
        self.send_header("content-length", "0")
        self.end_headers()

    def do_POST(self):
        size = int(self.headers.get("content-length", "0"))
        self.rfile.read(size)
        requests.append({
            "method": "POST",
            "path": self.path,
            "upgrade": self.headers.get("Upgrade"),
        })

        response_id = "resp_local_fixture"
        item = {
            "id": "msg_local_fixture",
            "type": "message",
            "status": "completed",
            "role": "assistant",
            "content": [{
                "type": "output_text",
                "text": "DONE",
                "annotations": [],
            }],
        }
        completed = {
            "id": response_id,
            "object": "response",
            "created_at": 0,
            "status": "completed",
            "error": None,
            "incomplete_details": None,
            "instructions": None,
            "max_output_tokens": None,
            "model": "synthetic-local-model",
            "output": [item],
            "parallel_tool_calls": True,
            "previous_response_id": None,
            "reasoning": {"effort": "none", "summary": None},
            "store": False,
            "temperature": None,
            "text": {"format": {"type": "text"}},
            "tool_choice": "auto",
            "tools": [],
            "top_p": None,
            "truncation": "disabled",
            "usage": {"input_tokens": 1, "output_tokens": 1, "total_tokens": 2},
            "metadata": {},
        }
        events = [
            {
                "type": "response.created",
                "response": dict(completed, status="in_progress", output=[]),
            },
            {
                "type": "response.output_item.added",
                "response_id": response_id,
                "output_index": 0,
                "item": dict(item, status="in_progress", content=[]),
            },
            {
                "type": "response.output_text.delta",
                "response_id": response_id,
                "item_id": item["id"],
                "output_index": 0,
                "content_index": 0,
                "delta": "DONE",
            },
            {
                "type": "response.output_item.done",
                "response_id": response_id,
                "output_index": 0,
                "item": item,
            },
            {"type": "response.completed", "response": completed},
        ]
        payload = b"".join(
            f"event: {event['type']}\ndata: "
            f"{json.dumps(event, separators=(',', ':'))}\n\n".encode()
            for event in events
        ) + b"data: [DONE]\n\n"
        self.send_response(200)
        self.send_header("content-type", "text/event-stream")
        self.send_header("content-length", str(len(payload)))
        self.end_headers()
        self.wfile.write(payload)


with tempfile.TemporaryDirectory(prefix="codex-426-") as temporary:
    root = Path(temporary)
    home = root / "home"
    project = root / "project"
    codex_home = home / ".codex"
    codex_home.mkdir(parents=True)
    project.mkdir()
    (codex_home / "config.toml").write_text(
        f'[projects."{project}"]\ntrust_level = "trusted"\n',
        encoding="utf-8",
    )

    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
    threading.Thread(target=server.serve_forever, daemon=True).start()
    base_url = f"http://127.0.0.1:{server.server_port}/v1"
    environment = {
        "HOME": str(home),
        "CODEX_HOME": str(codex_home),
        "OPENAI_API_KEY": "synthetic-local-only",
        "PATH": os.environ["PATH"],
        "TERM": "dumb",
        "NO_COLOR": "1",
    }
    binary = Path(__file__).parent / "node_modules" / ".bin" / "codex"
    version = subprocess.run(
        [binary, "--version"],
        env=environment,
        text=True,
        capture_output=True,
        timeout=10,
        check=True,
    ).stdout.strip()
    result = subprocess.run(
        [
            binary,
            "-c",
            f'openai_base_url="{base_url}"',
            "exec",
            "--dangerously-bypass-approvals-and-sandbox",
            "--skip-git-repo-check",
            "--model",
            "synthetic-local-model",
            "Return the fixture response.",
        ],
        cwd=project,
        env=environment,
        stdin=subprocess.DEVNULL,
        text=True,
        capture_output=True,
        timeout=20,
    )
    server.shutdown()

    print(json.dumps({
        "version": version,
        "exit": result.returncode,
        "requests": requests,
        "stdout": result.stdout,
        "stderr": result.stderr,
    }, indent=2))