codex-as-api 0.8.0__tar.gz → 0.8.2__tar.gz

codex_as_api-0.8.0/README.md → codex_as_api-0.8.2/PKG-INFO

@@ -1,3 +1,37 @@
+Metadata-Version: 2.5
+Name: codex-as-api
+Version: 0.8.2
+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
+Author: Eunho-J
+License: Apache-2.0
+License-File: LICENSE
+Keywords: api,chatgpt,codex,llm,oauth,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.100
+Requires-Dist: pydantic>=2.0
+Requires-Dist: regex
+Requires-Dist: tomli>=2; python_version < '3.11'
+Requires-Dist: uvicorn>=0.23
+Provides-Extra: dev
+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
+
 # codex-as-api
 
 [![GitHub Release](https://img.shields.io/github/v/release/Eunho-J/codex-as-api)](https://github.com/Eunho-J/codex-as-api/releases)
@@ -537,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).
 

codex_as_api-0.8.0/PKG-INFO → codex_as_api-0.8.2/README.md

@@ -1,36 +1,3 @@
-Metadata-Version: 2.5
-Name: codex-as-api
-Version: 0.8.0
-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
-Author: Eunho-J
-License: Apache-2.0
-License-File: LICENSE
-Keywords: api,chatgpt,codex,llm,oauth,openai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.100
-Requires-Dist: pydantic>=2.0
-Requires-Dist: regex
-Requires-Dist: tomli>=2; python_version < '3.11'
-Requires-Dist: uvicorn>=0.23
-Provides-Extra: dev
-Requires-Dist: httpx; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: types-regex; extra == 'dev'
-Description-Content-Type: text/markdown
-
 # codex-as-api
 
 [![GitHub Release](https://img.shields.io/github/v/release/Eunho-J/codex-as-api)](https://github.com/Eunho-J/codex-as-api/releases)
@@ -570,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).
 

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/RELEASES.md

@@ -1,5 +1,39 @@
 # Release Notes
 
+## v0.8.2
+
+### Hotfix: disjoint Anthropic cache usage (all runtimes)
+
+- Correct Anthropic Messages usage in streaming and non-streaming responses:
+  `input_tokens` now excludes both cache reads and reported cache creation,
+  which remain in their separate `cache_read_input_tokens` and
+  `cache_creation_input_tokens` counters. Previously, consumers adding those
+  counters counted cached input twice.
+- Keep OpenAI/Responses totals unchanged. Preserve unknown cache counters as
+  null; subtract only reported cache buckets. Reject impossible cache sums
+  exceeding the upstream input total instead of emitting negative/clamped usage.
+- Add no-cache, partial/full-cache, cache-write, invalid-total and HTTP pipeline
+  regressions across TypeScript, Python and Rust. Example: 100 total input,
+  50 cache read and 25 cache write becomes 25 uncached + 50 read + 25 write.
+
+## 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)

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-as-api"
-version = "0.8.0"
+version = "0.8.2"
 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.8.0 → codex_as_api-0.8.2}/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.8.0"
+__version__ = "0.8.2"

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/src/codex_as_api/anthropic_adapter.py

@@ -718,13 +718,23 @@ def _reject_unrepresentable_response_events(raw: dict | None) -> None:
         )
 
 
+def _uncached_input_tokens(total: int, cache_read: int | None, cache_write: int | None) -> int:
+    # OpenAI totals include cache buckets; Anthropic exposes disjoint counters.
+    cached = (cache_read or 0) + (cache_write or 0)
+    if cached > total:
+        raise ChatGPTOAuthProtocolError("usage cache tokens must not exceed input_tokens")
+    return total - cached
+
+
 def _anthropic_usage_from_internal(usage: Usage) -> dict[str, Any]:
     return {
         "cache_creation": None,
         "cache_creation_input_tokens": usage.cache_write_tokens,
         "cache_read_input_tokens": usage.cached_tokens,
         "inference_geo": None,
-        "input_tokens": usage.prompt_tokens,
+        "input_tokens": _uncached_input_tokens(
+            usage.prompt_tokens, usage.cached_tokens, usage.cache_write_tokens
+        ),
         "iterations": None,
         "output_tokens": usage.completion_tokens,
         "server_tool_use": None,
@@ -910,7 +920,7 @@ def _anthropic_usage_from_provider(usage: Any) -> dict[str, Any]:
     out: dict[str, Any] = {
         "cache_creation_input_tokens": cache_write,
         "cache_read_input_tokens": cache_read,
-        "input_tokens": input_tokens,
+        "input_tokens": _uncached_input_tokens(input_tokens, cache_read, cache_write),
         "iterations": None,
         "output_tokens": output_tokens,
         "server_tool_use": server_tool_use,

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/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.8.0 → codex_as_api-0.8.2}/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.8.0",
+    version="0.8.2",
 )
 
 

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/tests/test_anthropic_adapter.py

@@ -1206,6 +1206,23 @@ class TestInternalResponseToAnthropic:
         result = internal_response_to_anthropic(resp, "m", "msg_1")
         assert result["usage"]["cache_read_input_tokens"] == 50
         assert result["usage"]["cache_creation_input_tokens"] == 25
+        assert result["usage"]["input_tokens"] == 25
+
+    @pytest.mark.parametrize("read,write", [(0, 0), (40, 0), (100, 0), (0, 100), (40, 60), (101, 0), (60, 41)])
+    def test_disjoint_cache_buckets(self, read, write):
+        source = Usage(prompt_tokens=100, completion_tokens=7, total_tokens=107,
+                       cached_tokens=read, cache_write_tokens=write)
+        response = AssistantResponse(content="hi", tool_calls=(), finish_reason="stop",
+                                     usage=source, reasoning_content=None, raw=None)
+        if read + write > 100:
+            with pytest.raises(ChatGPTOAuthProtocolError, match="cache tokens must not exceed"):
+                internal_response_to_anthropic(response, "m", "msg")
+        else:
+            usage = internal_response_to_anthropic(response, "m", "msg")["usage"]
+            assert usage["input_tokens"] == 100 - read - write
+            buckets = ("input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens")
+            assert sum(usage[k] for k in buckets) == 100
+            assert source.prompt_tokens == 100
 
     def test_web_search_provider_output_is_rejected(self):
         resp = AssistantResponse(
@@ -1460,7 +1477,7 @@ class TestAnthropicStreamAdapter:
         assert msg_delta["usage"] == {
             "cache_creation_input_tokens": 11,
             "cache_read_input_tokens": 13,
-            "input_tokens": 123,
+            "input_tokens": 99,
             "iterations": None,
             "output_tokens": 7,
             "server_tool_use": {"web_search_requests": 2, "web_fetch_requests": 1},
@@ -1516,6 +1533,22 @@ class TestAnthropicStreamAdapter:
         with pytest.raises(ChatGPTOAuthProtocolError, match="provider (finish )?usage"):
             self._collect_events(events)
 
+    @pytest.mark.parametrize("read,write", [(0, 0), (40, 0), (100, 0), (0, 100), (40, 60), (101, 0), (60, 41)])
+    def test_stream_disjoint_cache_buckets(self, read, write):
+        source = {"input_tokens": 100, "output_tokens": 7, "total_tokens": 107,
+                  "input_tokens_details": {"cached_tokens": read, "cache_write_tokens": write}}
+        events = [{"type": "finish", "finish_reason": "stop", "usage": source}]
+        if read + write > 100:
+            with pytest.raises(ChatGPTOAuthProtocolError, match="cache tokens must not exceed"):
+                self._collect_events(events)
+        else:
+            result = self._collect_events(events)
+            usage = next(e["usage"] for e in result if e["type"] == "message_delta")
+            assert usage["input_tokens"] == 100 - read - write
+            buckets = ("input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens")
+            assert sum(usage[k] for k in buckets) == 100
+            assert source["input_tokens"] == 100
+
     def test_maps_responses_cache_write_details_into_message_delta(self):
         result = self._collect_events(
             [

{codex_as_api-0.8.0 → codex_as_api-0.8.2}/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.8.0 → codex_as_api-0.8.2}/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.8.0")
+    assert headers["User-Agent"].endswith(") codex-as-api/0.8.2")
 
 
 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.8.0")
+    assert headers["User-Agent"].endswith(") codex-as-api/0.8.2")
     assert headers["Authorization"].startswith("Bearer ")
 
 

codex_as_api-0.8.2/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()