codex-as-api 0.7.0__tar.gz → 0.8.1__tar.gz

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codex-as-api
-Version: 0.7.0
+Version: 0.8.1
 Summary: Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server.
 Project-URL: Homepage, https://github.com/Eunho-J/codex-as-api
 Project-URL: Repository, https://github.com/Eunho-J/codex-as-api
@@ -28,6 +28,7 @@ Requires-Dist: httpx; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: tomli>=2.0.1; extra == 'dev'
 Requires-Dist: types-regex; extra == 'dev'
 Description-Content-Type: text/markdown
 
@@ -463,6 +464,36 @@ Readiness check. It returns `200` only when OAuth is available, a fresh catalog
 curl -i http://localhost:18080/health
 ```
 
+### `POST /v1/realtime/calls` (TypeScript)
+
+Creates a ChatGPT Live (realtime voice) call on the OAuth-authenticated ChatGPT
+backend. The client owns the media plane: it sends its own WebRTC SDP offer and
+applies the returned answer, so no audio is relayed through this proxy.
+
+The body is `{"sdp": "<offer>", "session": {...}}`. `session` may carry
+`instructions`, a `voice` (default `cove`), and any additional ChatGPT Live
+session field; `model` defaults to `gpt-live-1-codex`, and `delegation` defaults
+to `{"type": "client"}`. The route rejects unknown top-level fields and any
+client-chosen voice-session id (`id`, `session_id`, `voice_session_id`), because
+the backend denies calls that set those itself. On success it returns `201` with
+the SDP answer as `text/plain` and a mirror `Location: /v1/realtime/calls/{call_id}`.
+
+```bash
+curl -i http://localhost:18080/v1/realtime/calls \
+  -H "Content-Type: application/json" \
+  -d '{"sdp": "v=0\r\n...", "session": {"instructions": "Reply briefly."}}'
+```
+
+### `WS /v1/realtime/sideband/{call_id}` (TypeScript)
+
+Relays a WebSocket to the OpenAI realtime sideband of an already-created call
+(`wss://api.openai.com/v1/live/{call_id}`) with the account's OAuth headers, so a
+headless client — a bot, a server-side agent, or an observer attached to the same
+call — can read and write realtime events without running the media plane.
+Frames, text and binary, are forwarded verbatim; the proxy does not rewrite or
+invent session events. Browser clients that already hold the `oai-events` data
+channel do not need this route.
+
 ## Codex-Specific Features
 
 These features are extensions beyond the standard OpenAI API, designed for Codex CLI compatibility.
@@ -540,6 +571,23 @@ The mapping is intentionally transport-aware:
 | `previous_response_id` | Resolve locally and replay complete Response history over HTTP |
 | `service_tier: "fast"` | Send `service_tier: "priority"` |
 | `service_tier: "default"` | Omit the field |
+| `service_tier: "ultrafast"` | Send `service_tier: "ultrafast"` only when the live model advertises it |
+| Messages/compact `speed: "ultrafast"` (proxy extension) | Resolve to `service_tier: "ultrafast"`, with the same catalog check |
+
+Ultra Fast is distinct from Fast (`priority`), not a reasoning effort. For OpenAI
+Chat requests use `"service_tier": "ultrafast"`; for `/v1/messages` and
+`/v1/messages/compact` either that field or the proxy extension
+`"speed": "ultrafast"` is accepted. If both fields are supplied they must agree.
+Unsupported tiers return HTTP 400 before an inference request, including streaming
+requests; the proxy never silently downgrades Ultra Fast to priority. Check the
+account-specific `service_tiers` returned by `GET /v1/models`. An official feature
+flag does not grant account access or change pricing. `speed: "ultrafast"` is not
+claimed as an official Anthropic field, and existing `speed: "fast"` behavior is
+unchanged. The proxy does not inherit speed defaults from Codex config.
+
+Official behavior reference: Codex [0.164.0 service-tier resolution](https://github.com/openai/codex/blob/rust-v0.164.0/codex-rs/tui/src/service_tier_resolution.rs)
+and [stable, enabled-by-default ultrafast feature](https://github.com/openai/codex/blob/rust-v0.164.0/codex-rs/features/src/lib.rs).
+The rest of the private HTTP contract remains pinned to 0.153.3.
 
 Authenticated tests on July 10, 2026 verified both official continuation paths with `gpt-5.6-sol`: a direct private Responses WebSocket completed a second delta request using the exact prior `response.id`, and the private HTTP endpoint completed the same continuation when the full prior input/output history was replayed. The proxy implements the HTTP replay strategy. Direct HTTP forwarding of `previous_response_id`, Pro, public cache controls, and `safety_identifier` was rejected and is not used. See OpenAI's [reasoning mode documentation](https://developers.openai.com/api/docs/guides/reasoning#reasoning-mode) and the Codex 0.153.3 [HTTP/WebSocket request structures](https://github.com/openai/codex/blob/b1a547b1f73ce86205d9222ac19cff334b3b7a2e/codex-rs/codex-api/src/common.rs#L275-L350).
 
@@ -812,6 +860,7 @@ The provider handles:
 - Bounded, account-scoped `previous_response_id` history replay over private HTTP
 - Multimodal Chat input, image generation/inspection, and capability-gated classic `original` detail
 - Remote conversation compaction
+- ChatGPT Live realtime call creation and a sideband event relay, in the TypeScript runtime only
 
 ## Release & package publishing
 
@@ -841,9 +890,9 @@ registry setup is still required:
 After bumping every version and passing the local gate, push the matching tag:
 
 ```bash
-python scripts/check_package_versions.py --tag v0.7.0
-git tag v0.7.0
-git push origin v0.7.0
+python scripts/check_package_versions.py --tag v0.8.0
+git tag v0.8.0
+git push origin v0.8.0
 ```
 
 ## Tests
@@ -874,6 +923,20 @@ npm test
 
 ## Release Notes
 
+### v0.8.0
+
+- Add ChatGPT Live realtime voice to the TypeScript runtime: `POST
+  /v1/realtime/calls` creates an OAuth-authorized call from a client-owned WebRTC
+  SDP offer and returns the SDP answer, and `WS /v1/realtime/sideband/{call_id}`
+  relays the OpenAI realtime event sideband for headless clients. Audio stays on
+  the client's media plane.
+- Mirror the pinned Codex call contract exactly: one identity in
+  `x-session-id`/`session-id`/`thread-id`, the `openai-alpha: quicksilver=v2`
+  handshake, `intent=quicksilver&architecture=avas`, and a session payload that
+  never chooses its own voice-session id.
+- Document realtime as a TypeScript-only capability; Python and Rust remain
+  HTTP-only in this release instead of claiming cross-runtime parity.
+
 ### v0.7.0
 
 - Replace bundled model capability tables with a fresh authenticated Codex

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/README.md

@@ -430,6 +430,36 @@ Readiness check. It returns `200` only when OAuth is available, a fresh catalog
 curl -i http://localhost:18080/health
 ```
 
+### `POST /v1/realtime/calls` (TypeScript)
+
+Creates a ChatGPT Live (realtime voice) call on the OAuth-authenticated ChatGPT
+backend. The client owns the media plane: it sends its own WebRTC SDP offer and
+applies the returned answer, so no audio is relayed through this proxy.
+
+The body is `{"sdp": "<offer>", "session": {...}}`. `session` may carry
+`instructions`, a `voice` (default `cove`), and any additional ChatGPT Live
+session field; `model` defaults to `gpt-live-1-codex`, and `delegation` defaults
+to `{"type": "client"}`. The route rejects unknown top-level fields and any
+client-chosen voice-session id (`id`, `session_id`, `voice_session_id`), because
+the backend denies calls that set those itself. On success it returns `201` with
+the SDP answer as `text/plain` and a mirror `Location: /v1/realtime/calls/{call_id}`.
+
+```bash
+curl -i http://localhost:18080/v1/realtime/calls \
+  -H "Content-Type: application/json" \
+  -d '{"sdp": "v=0\r\n...", "session": {"instructions": "Reply briefly."}}'
+```
+
+### `WS /v1/realtime/sideband/{call_id}` (TypeScript)
+
+Relays a WebSocket to the OpenAI realtime sideband of an already-created call
+(`wss://api.openai.com/v1/live/{call_id}`) with the account's OAuth headers, so a
+headless client — a bot, a server-side agent, or an observer attached to the same
+call — can read and write realtime events without running the media plane.
+Frames, text and binary, are forwarded verbatim; the proxy does not rewrite or
+invent session events. Browser clients that already hold the `oai-events` data
+channel do not need this route.
+
 ## Codex-Specific Features
 
 These features are extensions beyond the standard OpenAI API, designed for Codex CLI compatibility.
@@ -507,6 +537,23 @@ The mapping is intentionally transport-aware:
 | `previous_response_id` | Resolve locally and replay complete Response history over HTTP |
 | `service_tier: "fast"` | Send `service_tier: "priority"` |
 | `service_tier: "default"` | Omit the field |
+| `service_tier: "ultrafast"` | Send `service_tier: "ultrafast"` only when the live model advertises it |
+| Messages/compact `speed: "ultrafast"` (proxy extension) | Resolve to `service_tier: "ultrafast"`, with the same catalog check |
+
+Ultra Fast is distinct from Fast (`priority`), not a reasoning effort. For OpenAI
+Chat requests use `"service_tier": "ultrafast"`; for `/v1/messages` and
+`/v1/messages/compact` either that field or the proxy extension
+`"speed": "ultrafast"` is accepted. If both fields are supplied they must agree.
+Unsupported tiers return HTTP 400 before an inference request, including streaming
+requests; the proxy never silently downgrades Ultra Fast to priority. Check the
+account-specific `service_tiers` returned by `GET /v1/models`. An official feature
+flag does not grant account access or change pricing. `speed: "ultrafast"` is not
+claimed as an official Anthropic field, and existing `speed: "fast"` behavior is
+unchanged. The proxy does not inherit speed defaults from Codex config.
+
+Official behavior reference: Codex [0.164.0 service-tier resolution](https://github.com/openai/codex/blob/rust-v0.164.0/codex-rs/tui/src/service_tier_resolution.rs)
+and [stable, enabled-by-default ultrafast feature](https://github.com/openai/codex/blob/rust-v0.164.0/codex-rs/features/src/lib.rs).
+The rest of the private HTTP contract remains pinned to 0.153.3.
 
 Authenticated tests on July 10, 2026 verified both official continuation paths with `gpt-5.6-sol`: a direct private Responses WebSocket completed a second delta request using the exact prior `response.id`, and the private HTTP endpoint completed the same continuation when the full prior input/output history was replayed. The proxy implements the HTTP replay strategy. Direct HTTP forwarding of `previous_response_id`, Pro, public cache controls, and `safety_identifier` was rejected and is not used. See OpenAI's [reasoning mode documentation](https://developers.openai.com/api/docs/guides/reasoning#reasoning-mode) and the Codex 0.153.3 [HTTP/WebSocket request structures](https://github.com/openai/codex/blob/b1a547b1f73ce86205d9222ac19cff334b3b7a2e/codex-rs/codex-api/src/common.rs#L275-L350).
 
@@ -779,6 +826,7 @@ The provider handles:
 - Bounded, account-scoped `previous_response_id` history replay over private HTTP
 - Multimodal Chat input, image generation/inspection, and capability-gated classic `original` detail
 - Remote conversation compaction
+- ChatGPT Live realtime call creation and a sideband event relay, in the TypeScript runtime only
 
 ## Release & package publishing
 
@@ -808,9 +856,9 @@ registry setup is still required:
 After bumping every version and passing the local gate, push the matching tag:
 
 ```bash
-python scripts/check_package_versions.py --tag v0.7.0
-git tag v0.7.0
-git push origin v0.7.0
+python scripts/check_package_versions.py --tag v0.8.0
+git tag v0.8.0
+git push origin v0.8.0
 ```
 
 ## Tests
@@ -841,6 +889,20 @@ npm test
 
 ## Release Notes
 
+### v0.8.0
+
+- Add ChatGPT Live realtime voice to the TypeScript runtime: `POST
+  /v1/realtime/calls` creates an OAuth-authorized call from a client-owned WebRTC
+  SDP offer and returns the SDP answer, and `WS /v1/realtime/sideband/{call_id}`
+  relays the OpenAI realtime event sideband for headless clients. Audio stays on
+  the client's media plane.
+- Mirror the pinned Codex call contract exactly: one identity in
+  `x-session-id`/`session-id`/`thread-id`, the `openai-alpha: quicksilver=v2`
+  handshake, `intent=quicksilver&architecture=avas`, and a session payload that
+  never chooses its own voice-session id.
+- Document realtime as a TypeScript-only capability; Python and Rust remain
+  HTTP-only in this release instead of claiming cross-runtime parity.
+
 ### v0.7.0
 
 - Replace bundled model capability tables with a fresh authenticated Codex

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/RELEASES.md

@@ -1,5 +1,48 @@
 # Release Notes
 
+## v0.8.1
+
+### Explicit Ultra Fast selection (all runtimes)
+
+- Accept `speed: "ultrafast"` as a proxy extension on Anthropic Messages and
+  compact routes and forward the literal Codex `service_tier: "ultrafast"`.
+  Direct `service_tier` selection remains supported on Chat and Messages.
+- Preserve live account/model tier validation: unavailable Ultra Fast is HTTP
+  400 before inference/streaming headers, never a silent downgrade to priority.
+  Reject conflicting speed/tier inputs; keep Fast and standard behavior unchanged.
+- Add cross-runtime mapping and capability regression tests, including HTTP
+  recording-backend tests. Malformed Python speed objects/arrays now return
+  invalid-request errors instead of causing an unhashable-type failure.
+- Keep TOML config imports type-checkable on current Python while preserving
+  Python 3.10 support; include `tomli` in dev dependencies for the 3.10 analysis target.
+- Document Ultra Fast separately from priority and reasoning effort. No model
+  support, account entitlement, pricing or config speed default is invented.
+
+## v0.8.0
+
+### ChatGPT Live realtime voice (TypeScript)
+
+- Add `POST /v1/realtime/calls` to the TypeScript runtime. A client-owned WebRTC
+  SDP offer plus an optional `session` object (`instructions`, `voice`, ...) is
+  exchanged for the ChatGPT backend's SDP answer; the call id is returned both in
+  the mirrored `Location: /v1/realtime/calls/{call_id}` header and as
+  `x-realtime-call-id`, and the answer body is `text/plain`, never JSON.
+- Add `WS /v1/realtime/sideband/{call_id}`, which relays text and binary realtime
+  frames to `wss://api.openai.com/v1/live/{call_id}` with the account's OAuth
+  headers so headless clients (bots, server-side agents, observers) can attach to
+  an existing call. The proxy does not proxy RTP; the media plane stays client-side.
+- Send the exact call contract the backend authorizes for OAuth: `version`,
+  `openai-alpha: quicksilver=v2`, `session-id`/`x-session-id`/`thread-id` carrying
+  one minted identity, and `intent=quicksilver&architecture=avas`. Reject unknown
+  top-level request fields and any client-chosen voice-session id (`id`,
+  `session_id`, `voice_session_id`) instead of forwarding a call the backend
+  denies.
+- Default `model` to `gpt-live-1-codex`, `voice` to `cove`, and `delegation` to
+  `{"type": "client"}`.
+- Realtime is TypeScript-only in this release. The Python and Rust runtimes keep
+  their existing HTTP surface, and the runtime difference is stated in
+  `README.md` and `ts/README.md` rather than presented as parity.
+
 ## v0.7.0
 
 ### Live authenticated model catalog

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-as-api"
-version = "0.7.0"
+version = "0.8.1"
 description = "Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -33,7 +33,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["pytest", "ruff", "mypy", "httpx", "types-regex"]
+dev = ["pytest", "ruff", "mypy", "httpx", "types-regex", "tomli>=2.0.1"]
 
 [project.scripts]
 codex-as-api = "codex_as_api.server:main"

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/src/codex_as_api/__init__.py

@@ -1,3 +1,3 @@
 """codex-as-api: Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server."""
 
-__version__ = "0.7.0"
+__version__ = "0.8.1"

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/src/codex_as_api/codex_config.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 import os
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-try:
-    import tomllib  # type: ignore[import-not-found]
-except ModuleNotFoundError:  # pragma: no cover - Python 3.10 compatibility
-    import tomli as tomllib  # type: ignore[import-not-found]
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover - Python 3.10 compatibility
+    import tomli as tomllib
 
 
 _JS_SAFE_INTEGER = 9_007_199_254_740_991

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/src/codex_as_api/server.py

@@ -271,10 +271,10 @@ def _anthropic_service_tier(body: dict[str, Any]) -> str | None:
     speed = body.get("speed")
     if speed is None:
         return cast(str | None, service_tier)
-    if speed not in {"fast", "standard"}:
-        raise ChatGPTOAuthInvalidRequestError("speed must be one of: fast, standard")
-    speed_tier = "fast" if speed == "fast" else "default"
-    equivalent_tiers = {"fast", "priority"} if speed == "fast" else {"default"}
+    if not isinstance(speed, str) or speed not in {"fast", "standard", "ultrafast"}:
+        raise ChatGPTOAuthInvalidRequestError("speed must be one of: fast, standard, ultrafast")
+    speed_tier = "default" if speed == "standard" else speed
+    equivalent_tiers = {"fast", "priority"} if speed == "fast" else {speed_tier}
     if service_tier is not None and service_tier not in equivalent_tiers:
         raise ChatGPTOAuthInvalidRequestError("speed conflicts with service_tier")
     return speed_tier
@@ -497,7 +497,7 @@ def _health_error_message(exc: BaseException) -> str:
 app = FastAPI(
     title="codex-as-api",
     description="Local OpenAI-compatible API server backed by ChatGPT/Codex OAuth.",
-    version="0.7.0",
+    version="0.8.1",
 )
 
 

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/tests/test_model_capabilities.py

@@ -89,6 +89,24 @@ def test_catalog_parser_diagnostics_do_not_reflect_slug_or_modality_values(
     assert parsed.models[0].input_modalities == ("audio", "text")
 
 
+def test_ultrafast_preserves_live_tier_and_rejects_unavailable(model_catalog_document) -> None:
+    document = deepcopy(model_catalog_document)
+    document["models"][0]["service_tiers"] = [
+        {"id": "ultrafast", "name": "Ultra Fast", "description": "Ultra Fast"},
+    ]
+    capability = _parse(document).models[0]
+    payload = {}
+    apply_model_capability_fields(
+        payload, capability=capability, text=None, service_tier="ultrafast",
+    )
+    assert payload["service_tier"] == "ultrafast"
+    unavailable = _parse(model_catalog_document).models[0]
+    with pytest.raises(ValueError, match="service_tier"):
+        apply_model_capability_fields(
+            {}, capability=unavailable, text=None, service_tier="ultrafast",
+        )
+
+
 def test_invalid_model_control_diagnostics_do_not_reflect_values(
     model_catalog_document,
 ) -> None:

{codex_as_api-0.7.0 → codex_as_api-0.8.1}/tests/test_provider.py

@@ -2158,7 +2158,7 @@ def test_codex_cli_headers_include_official_originator_and_versioned_user_agent(
 
     assert headers["originator"] == "codex_cli_rs"
     assert headers["User-Agent"].startswith("codex_cli_rs/0.153.3 (")
-    assert headers["User-Agent"].endswith(") codex-as-api/0.7.0")
+    assert headers["User-Agent"].endswith(") codex-as-api/0.8.1")
 
 
 def test_codex_cli_headers_reject_unpinned_version():
@@ -2881,7 +2881,7 @@ def test_provider_headers_include_codex_cli_headers(auth_json_factory):
 
     assert headers["originator"] == "codex_cli_rs"
     assert headers["User-Agent"].startswith("codex_cli_rs/0.153.3 (")
-    assert headers["User-Agent"].endswith(") codex-as-api/0.7.0")
+    assert headers["User-Agent"].endswith(") codex-as-api/0.8.1")
     assert headers["Authorization"].startswith("Bearer ")
 
 

codex_as_api-0.8.1/tests/test_ultrafast.py

@@ -0,0 +1,159 @@
+"""The proxy speed extension must not alias Ultra Fast to ordinary priority."""
+
+import pytest
+
+from codex_as_api.auth import ChatGPTOAuthInvalidRequestError
+from codex_as_api.server import _anthropic_service_tier
+
+# Reuse the real provider + loopback HTTP backend, rather than mocking the
+# provider methods (which would bypass live-catalog tier validation).
+from tests.test_server import client, recording_backend  # noqa: F401
+
+# Imported pytest fixtures are intentionally injected by argument name.
+# ruff: noqa: F811
+
+
+@pytest.fixture(autouse=True)
+def _isolate_ultrafast_http_environment(monkeypatch):
+    monkeypatch.setenv("CODEX_AS_API_RESPONSES_LITE", "auto")
+
+
+@pytest.fixture()
+def ultrafast_catalog(model_catalog_document):
+    model = next(
+        model for model in model_catalog_document["models"]
+        if model["slug"] == "gpt-5.6-sol"
+    )
+    model["service_tiers"].append({
+        "id": "ultrafast",
+        "name": "Ultra Fast",
+        "description": "Test-only advertised Ultra Fast tier",
+    })
+    return model_catalog_document
+
+
+@pytest.mark.parametrize("fields", [
+    {"speed": "ultrafast"},
+    {"speed": "ultrafast", "service_tier": "ultrafast"},
+    {"service_tier": "ultrafast"},
+])
+def test_ultrafast_speed_resolves_without_downgrade(fields):
+    assert _anthropic_service_tier(fields) == "ultrafast"
+
+
+@pytest.mark.parametrize("fields", [
+    {"speed": "ultrafast", "service_tier": "priority"},
+    {"speed": "fast", "service_tier": "ultrafast"},
+    {"speed": "standard", "service_tier": "ultrafast"},
+    {"speed": {}},
+    {"speed": []},
+])
+def test_ultrafast_conflicts_and_malformed_speed_are_invalid_requests(fields):
+    with pytest.raises(ChatGPTOAuthInvalidRequestError):
+        _anthropic_service_tier(fields)
+
+
+@pytest.mark.parametrize("stream", [False, True], ids=["nonstream", "stream"])
+@pytest.mark.parametrize("fields", [
+    {"speed": "ultrafast"},
+    {"service_tier": "ultrafast"},
+    {"speed": "ultrafast", "service_tier": "ultrafast"},
+], ids=["speed-alias", "direct-tier", "matching-controls"])
+def test_messages_ultrafast_reaches_recording_upstream(
+    ultrafast_catalog, client, recording_backend, stream, fields,
+):
+    response = client.post("/v1/messages", json={
+        "model": "gpt-5.6-sol",
+        "max_tokens": 64,
+        "messages": [{"role": "user", "content": "hello"}],
+        "stream": stream,
+        **fields,
+    })
+
+    assert response.status_code == 200, response.text
+    if stream:
+        assert response.headers["content-type"].startswith("text/event-stream")
+        assert "event: message_stop" in response.text
+        assert "backend-ok" in response.text
+        assert "event: error" not in response.text
+    else:
+        assert response.json()["content"][0]["type"] == "text"
+        assert response.json()["content"][0]["text"] == "backend-ok"
+    recorded = recording_backend.requests.get(timeout=1)
+    assert recorded["path"] == "/responses"
+    assert recorded["body"]["service_tier"] == "ultrafast"
+    assert "speed" not in recorded["body"]
+    assert recording_backend.requests.empty()
+
+
+@pytest.mark.parametrize("route, fields", [
+    ("/v1/messages/compact", {"speed": "ultrafast"}),
+    ("/v1/messages/compact", {"service_tier": "ultrafast"}),
+    ("/v1/messages/compact", {"speed": "ultrafast", "service_tier": "ultrafast"}),
+    ("/v1/compact", {"service_tier": "ultrafast"}),
+], ids=["speed-alias", "direct-tier", "matching-controls", "openai-compact"])
+def test_compact_ultrafast_reaches_recording_upstream(
+    ultrafast_catalog, client, recording_backend, route, fields,
+):
+    body = {
+        "model": "gpt-5.6-sol",
+        "messages": [{"role": "user", "content": "hello"}],
+        **fields,
+    }
+    if route == "/v1/messages/compact":
+        body["max_tokens"] = 64
+    response = client.post(route, json=body)
+
+    assert response.status_code == 200, response.text
+    recorded = recording_backend.requests.get(timeout=1)
+    assert recorded["path"] == "/responses/compact"
+    assert recorded["body"]["service_tier"] == "ultrafast"
+    assert "speed" not in recorded["body"]
+    assert recording_backend.requests.empty()
+
+
+@pytest.mark.parametrize("route, stream", [
+    ("/v1/messages", False),
+    ("/v1/messages", True),
+    ("/v1/messages/compact", False),
+])
+@pytest.mark.parametrize("fields", [
+    {"speed": "ultrafast"},
+    {"service_tier": "ultrafast"},
+], ids=["speed-alias", "direct-tier"])
+def test_unadvertised_ultrafast_rejected_before_recording_upstream(
+    client, recording_backend, route, stream, fields,
+):
+    # Default catalog advertises priority only: do not globally grant Ultra Fast
+    # in the common fixture, or this rejection guard would become untestable.
+    body = {
+        "model": "gpt-5.6-sol",
+        "max_tokens": 64,
+        "messages": [{"role": "user", "content": "hello"}],
+        **fields,
+    }
+    if route == "/v1/messages":
+        body["stream"] = stream
+    response = client.post(route, json=body)
+
+    assert response.status_code == 400, response.text
+    assert response.json()["error"]["type"] == "invalid_request_error"
+    assert "service_tier" in response.json()["error"]["message"]
+    assert recording_backend.requests.empty()
+    # Catalog discovery is permitted; no generation/compact POST may occur.
+    assert not recording_backend.catalog_requests.empty()
+
+
+def test_openai_compact_unadvertised_ultrafast_rejected_before_upstream(
+    client, recording_backend,
+):
+    response = client.post("/v1/compact", json={
+        "model": "gpt-5.6-sol",
+        "messages": [{"role": "user", "content": "hello"}],
+        "service_tier": "ultrafast",
+    })
+
+    assert response.status_code == 400, response.text
+    assert "service_tier" in response.json()["error"]["message"]
+    assert recording_backend.requests.empty()
+    assert not recording_backend.catalog_requests.empty()