codex-backend-sdk 0.5.3__tar.gz → 0.5.5__tar.gz

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.5.5] - 2026-10-22
+
+### Added
+- Added `client.responses.turn()` for ephemeral sticky routing within one logical
+  HTTP Responses turn, isolated across concurrent turns and invalidated when
+  authentication or cache affinity changes.
+
+### Changed
+- Forward Realtime model identifiers unchanged instead of maintaining a local
+  allowlist. Newly available Codex models, including `gpt-live-1.1`, no longer
+  require an SDK update; the backend determines availability and authorization.
+
+### Fixed
+- Supply the HTTP `session-id` cache-affinity header from `prompt_cache_key`
+  unless an explicit request or client header already sets it.
+- Route reset-credit requests through the authenticated WHAM API.
+- Preserve backend remote-compaction errors and close the response stream.
+- Align the exported package version with the distribution metadata.
+
+## [0.5.4] - 2026-09-24
+
+### Fixed
+- Preserve a bounded backend response body in raised HTTP errors so callers can
+  diagnose rejected requests without reconstructing the transport call.
+
 ## [0.5.3] - 2026-09-18
 
 ### Added

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codex-backend-sdk
-Version: 0.5.3
+Version: 0.5.5
 Summary: Unofficial Python SDK for the ChatGPT Codex backend API
 License: MIT
 License-File: LICENSE
@@ -51,6 +51,12 @@ The package intentionally separates three kinds of API:
 
 ## Install
 
+```bash
+pip install --upgrade codex-backend-sdk
+```
+
+For an editable checkout:
+
 ```bash
 git clone https://github.com/B4PT0R/codex-backend-sdk.git
 cd codex-backend-sdk
@@ -492,6 +498,31 @@ The ChatGPT read-aloud service is smaller than the public speech API: it exposes
 language and playback speed, not arbitrary model and voice selection. It can
 return a typed in-memory object, bytes, `BytesIO`, a data URI, or a file path.
 
+### Turn-scoped HTTP routing
+
+For an agent turn with several generations (tools or retries), use an isolated
+Responses resource. Continue sending the complete input as usual:
+
+```python
+with client.responses.turn() as turn:
+    first = turn.create(input=items, prompt_cache_key="conversation-id")
+    # Append model/tool results to items, then generate again in the same turn.
+    following = turn.create(input=items, prompt_cache_key="conversation-id")
+```
+
+The resource captures the first `x-codex-turn-state` from HTTP response headers
+or `response.metadata` events and replays it unchanged within this scope. The
+opaque routing token is never added to model input or persisted. Leaving the
+scope closes it; a new turn starts without the previous token. Authentication
+or cache-affinity changes invalidate it. Separate scopes do not share tokens,
+even on the same client. Streaming callers must consume the metadata event for
+an SSE-only token to be captured. Compaction remains a separate backend request
+and does not inherit the turn token; this scope does not manage WebSockets.
+
+`prompt_cache_key` also supplies the HTTP `session-id` affinity header unless
+an explicit request/client header overrides it (case-insensitively). These are
+routing mechanisms, not a guarantee of a cache hit or reduced quota usage.
+
 ## Advanced transports
 
 ### Realtime voice
@@ -512,9 +543,14 @@ with client.live.sideband.connect(session_id=live.session.id) as sideband:
         print(event.type)
 ```
 
-Live probes confirmed `gpt-live-1-codex` and
-`gpt-live-1-boulder-alpha`. They are Codex Realtime v3 snapshots, not aliases
-for the public `gpt-live-1` model. `client.live` follows the current
+Model identifiers are forwarded unchanged: the backend decides which models
+are available to your account, so new Codex models do not require an SDK update.
+Earlier call-creation probes accepted `gpt-live-1-codex` and
+`gpt-live-1-boulder-alpha`; these examples are not an exhaustive catalog.
+A `gpt-live-1.1` probe on October 22, 2026 also returned an SDP answer and
+connected WebRTC, but the server then rejected the voice session with
+`forbidden: Voice session access denied.` Call creation alone does not prove
+that an account can receive model responses. `client.live` follows the current
 `openai-python` creation, response, and sideband idioms while adapting them to
 the ChatGPT OAuth call transport.
 

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/README.md

@@ -22,6 +22,12 @@ The package intentionally separates three kinds of API:
 
 ## Install
 
+```bash
+pip install --upgrade codex-backend-sdk
+```
+
+For an editable checkout:
+
 ```bash
 git clone https://github.com/B4PT0R/codex-backend-sdk.git
 cd codex-backend-sdk
@@ -463,6 +469,31 @@ The ChatGPT read-aloud service is smaller than the public speech API: it exposes
 language and playback speed, not arbitrary model and voice selection. It can
 return a typed in-memory object, bytes, `BytesIO`, a data URI, or a file path.
 
+### Turn-scoped HTTP routing
+
+For an agent turn with several generations (tools or retries), use an isolated
+Responses resource. Continue sending the complete input as usual:
+
+```python
+with client.responses.turn() as turn:
+    first = turn.create(input=items, prompt_cache_key="conversation-id")
+    # Append model/tool results to items, then generate again in the same turn.
+    following = turn.create(input=items, prompt_cache_key="conversation-id")
+```
+
+The resource captures the first `x-codex-turn-state` from HTTP response headers
+or `response.metadata` events and replays it unchanged within this scope. The
+opaque routing token is never added to model input or persisted. Leaving the
+scope closes it; a new turn starts without the previous token. Authentication
+or cache-affinity changes invalidate it. Separate scopes do not share tokens,
+even on the same client. Streaming callers must consume the metadata event for
+an SSE-only token to be captured. Compaction remains a separate backend request
+and does not inherit the turn token; this scope does not manage WebSockets.
+
+`prompt_cache_key` also supplies the HTTP `session-id` affinity header unless
+an explicit request/client header overrides it (case-insensitively). These are
+routing mechanisms, not a guarantee of a cache hit or reduced quota usage.
+
 ## Advanced transports
 
 ### Realtime voice
@@ -483,9 +514,14 @@ with client.live.sideband.connect(session_id=live.session.id) as sideband:
         print(event.type)
 ```
 
-Live probes confirmed `gpt-live-1-codex` and
-`gpt-live-1-boulder-alpha`. They are Codex Realtime v3 snapshots, not aliases
-for the public `gpt-live-1` model. `client.live` follows the current
+Model identifiers are forwarded unchanged: the backend decides which models
+are available to your account, so new Codex models do not require an SDK update.
+Earlier call-creation probes accepted `gpt-live-1-codex` and
+`gpt-live-1-boulder-alpha`; these examples are not an exhaustive catalog.
+A `gpt-live-1.1` probe on October 22, 2026 also returned an SDP answer and
+connected WebRTC, but the server then rejected the voice session with
+`forbidden: Voice session access denied.` Call creation alone does not prove
+that an account can receive model responses. `client.live` follows the current
 `openai-python` creation, response, and sideband idioms while adapting them to
 the ChatGPT OAuth call transport.
 

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/__init__.py

@@ -17,7 +17,7 @@ Quickstart:
     print(response.output_text)
 """
 
-__version__ = "0.5.3"
+__version__ = "0.5.5"
 
 from .oauth import (
     DeviceCode,

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/_client.py

@@ -48,6 +48,7 @@ class CodexClient:
         from .resources.responses import Responses
 
         self._store = store
+        self._auth_revision = 0
         self._timeout = timeout
         self._max_retries = max_retries
         self._retry_base_delay = retry_base_delay
@@ -226,6 +227,7 @@ class CodexClient:
 
         cleared = clear_tokens()
         self._store = None
+        self._auth_revision += 1
         self._session.headers.pop("Authorization", None)
         self._session.headers.pop("ChatGPT-Account-ID", None)
         return cleared
@@ -245,6 +247,7 @@ class CodexClient:
         return self.logout()
 
     def _set_store(self, store: TokenStore) -> None:
+        self._auth_revision += 1
         self._store = store
         self._session.headers.update(self._auth_headers())
 

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/_streaming.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 from collections.abc import Iterator
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
 import requests
 
@@ -14,8 +14,12 @@ from ._models import ResponseStreamEvent
 class ResponseEventStream(Iterator[ResponseStreamEvent]):
     """Closeable/context-managed event stream compatible with OpenAI streams."""
 
-    def __init__(self, response: requests.Response) -> None:
+    def __init__(
+        self, response: requests.Response, *,
+        on_event: Optional[Callable[[ResponseStreamEvent], None]] = None,
+    ) -> None:
         self.response = response
+        self._on_event = on_event
         self._events = (
             ResponseStreamEvent.model_validate(payload)
             for payload in iter_sse_payloads(response)
@@ -25,7 +29,10 @@ class ResponseEventStream(Iterator[ResponseStreamEvent]):
         return self
 
     def __next__(self) -> ResponseStreamEvent:
-        return next(self._events)
+        event = next(self._events)
+        if self._on_event is not None:
+            self._on_event(event)
+        return event
 
     def close(self) -> None:
         close = getattr(self.response, "close", None)
@@ -39,8 +46,11 @@ class ResponseEventStream(Iterator[ResponseStreamEvent]):
         self.close()
 
 
-def stream_response_events(response: requests.Response) -> ResponseEventStream:
-    return ResponseEventStream(response)
+def stream_response_events(
+    response: requests.Response, *,
+    on_event: Optional[Callable[[ResponseStreamEvent], None]] = None,
+) -> ResponseEventStream:
+    return ResponseEventStream(response, on_event=on_event)
 
 
 def iter_sse_payloads(response: requests.Response) -> Iterator[dict[str, Any]]:

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/_transport.py

@@ -8,6 +8,26 @@ from typing import Any
 import requests
 
 
+_MAX_ERROR_DETAIL_CHARS = 4_000
+
+
+def raise_for_status_with_detail(response: requests.Response) -> None:
+    """Raise the usual HTTPError while retaining a bounded backend error body."""
+    try:
+        response.raise_for_status()
+    except requests.HTTPError as error:
+        detail = response.text.strip()
+        if not detail:
+            raise
+        if len(detail) > _MAX_ERROR_DETAIL_CHARS:
+            detail = detail[:_MAX_ERROR_DETAIL_CHARS] + "..."
+        raise requests.HTTPError(
+            f"{error}. Backend response: {detail}",
+            response=response,
+            request=error.request,
+        ) from error
+
+
 def request_with_retries(
     session: requests.Session,
     method: str,
@@ -26,7 +46,7 @@ def request_with_retries(
             if should_retry_response(response, attempt, max_retries=max_retries):
                 sleep_before_retry(response, attempt, retry_base_delay=retry_base_delay)
                 continue
-            response.raise_for_status()
+            raise_for_status_with_detail(response)
             return response
         except (requests.Timeout, requests.ConnectionError) as exc:
             last_error = exc

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/resources/_responses_payloads.py

@@ -251,7 +251,7 @@ def _event_error_message(event: ResponseStreamEvent) -> str:
     response = _event_response_dict(event)
     error = response.get("error") or getattr(event, "error", None) or {}
     if isinstance(error, dict):
-        return error.get("message", "Response failed")
+        return error.get("message") or getattr(event, "message", None) or "Response failed"
     return str(error)
 
 

codex_backend_sdk-0.5.5/codex_backend_sdk/resources/_responses_routing.py

@@ -0,0 +1,45 @@
+"""Ephemeral sticky routing for one Responses turn, never shared across turns."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from threading import Lock
+from typing import Any, Optional
+
+TURN_STATE_HEADER = "x-codex-turn-state"
+
+
+def header_value(headers: Any, name: str, default=None) -> Any:
+    if not isinstance(headers, Mapping):
+        return default
+    return next((value for key, value in headers.items() if key.lower() == name), default)
+
+
+class ResponsesTurnState:
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self._identity = None
+        self._value = None
+        self._epoch = 0
+        self._closed = False
+
+    def prepare(self, identity: tuple) -> tuple[int, Optional[str]]:
+        with self._lock:
+            if self._closed:
+                raise RuntimeError("Responses turn is closed.")
+            if self._identity != identity:
+                self._identity, self._value = identity, None
+                self._epoch += 1
+            return self._epoch, self._value
+
+    def capture(self, epoch: int, value: Any) -> None:
+        if not isinstance(value, str) or not value or "\r" in value or "\n" in value:
+            return
+        with self._lock:
+            if not self._closed and self._epoch == epoch and self._value is None:
+                self._value = value
+
+    def close(self) -> None:
+        with self._lock:
+            self._closed = True
+            self._identity = self._value = None

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/resources/codex.py

@@ -288,7 +288,7 @@ class CodexRateLimitResetCredits:
 
     def list(self) -> RateLimitResetCredits:
         return RateLimitResetCredits.model_validate(
-            self._client._get("/rate-limit-reset-credits")
+            self._client._get_wham("/wham/rate-limit-reset-credits")
         )
 
     def consume(
@@ -308,10 +308,9 @@ class CodexRateLimitResetCredits:
         if credit_id is not None:
             payload["credit_id"] = credit_id
         return ConsumeRateLimitResetCreditResponse.model_validate(
-            self._client._post(
-                "/rate-limit-reset-credits/consume",
-                body=payload,
-            ).json()
+            self._client._post_wham(
+                "/wham/rate-limit-reset-credits/consume", body=payload
+            )
         )
 
     def history(self, *, cursor: str | None = None) -> dict[str, Any]:

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/resources/realtime.py

@@ -24,12 +24,6 @@ if TYPE_CHECKING:
     from .._client import CodexClient
 
 
-CODEX_REALTIME_V3_MODELS = frozenset({
-    "gpt-live-1-codex",
-    "gpt-live-1-boulder-alpha",
-})
-
-
 class Realtime:
     """Realtime resources matching the official OpenAI SDK surface where present."""
 
@@ -362,9 +356,8 @@ class RealtimeSideband:
 class RealtimeCalls:
     """Codex WebRTC call creation over ChatGPT OAuth.
 
-    Realtime v3 uses the JSON call shape with one of the explicitly supported
-    Codex ``gpt-live`` snapshots. Arbitrary ``gpt-live`` aliases are not accepted
-    on this OAuth-authenticated route.
+    Realtime v3 uses the JSON call shape. Model identifiers are forwarded
+    unchanged; availability and validation belong to the backend.
     """
     def __init__(self, client: CodexClient) -> None:
         self._client = client
@@ -381,7 +374,7 @@ class RealtimeCalls:
         extra_body: Any = None,
         timeout: Any = _UNSET,
     ) -> RealtimeCallResponse:
-        """Create a Codex Realtime v3 call using a confirmed Codex model.
+        """Create a Codex Realtime v3 call with a backend-validated model.
 
         The ChatGPT backend requires both ``session-id`` and ``thread-id`` on
         v3 call creation. Fresh UUIDs are generated when callers do not need
@@ -393,13 +386,6 @@ class RealtimeCalls:
         if not isinstance(session_payload, dict):
             raise TypeError("Expected `session` to serialize to a JSON object.")
         session_payload.pop("id", None)
-        model = session_payload.get("model")
-        if model not in CODEX_REALTIME_V3_MODELS:
-            supported = ", ".join(sorted(CODEX_REALTIME_V3_MODELS))
-            raise ValueError(
-                "Codex Realtime v3 over ChatGPT OAuth requires "
-                f"one of these `session.model` values: {supported}."
-            )
         headers = {
             "session-id": session_id or str(uuid.uuid4()),
             "thread-id": thread_id or str(uuid.uuid4()),

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/codex_backend_sdk/resources/responses.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 import json
 import uuid
 from collections.abc import Iterator
-from typing import Any, TYPE_CHECKING
+from contextlib import contextmanager
+from hashlib import sha256
+from typing import Any, Optional, TYPE_CHECKING
 
 from .._models import CompactedResponse, ParsedResponse, Response, ResponseStreamEvent
 from .._streaming import stream_response_events
@@ -13,6 +15,7 @@ from .._utils import _UNSET, _default, _is_given, _jsonable, _reject_backend_uns
 from ._responses_payloads import (
     ResponsesCreateRequest,
     _usage_from_backend,
+    _event_error_message,
     collect_response,
     merge_text_format,
     normalize_input_item,
@@ -22,17 +25,47 @@ from ._responses_payloads import (
     pydantic_to_format,
 )
 
+from ._responses_routing import ResponsesTurnState, TURN_STATE_HEADER, header_value
+
 if TYPE_CHECKING:
     from .._client import CodexClient
 
 
+def _cache_affinity_headers(payload, extra_headers, default_headers=None):
+    headers = dict(extra_headers or {})
+    # Codex routes ChatGPT prompt caches using this header, not only the body key.
+    key = payload.get("prompt_cache_key")
+    if (
+        key
+        and not any(name.lower() == "session-id" for name in headers)
+        and not any(name.lower() == "session-id" for name in (default_headers or {}))
+    ):
+        headers["session-id"] = key
+    return headers or None
+
+
 class Responses:
-    def __init__(self, client: CodexClient) -> None:
+    def __init__(self, client: CodexClient, *, _turn_state: Optional[ResponsesTurnState] = None) -> None:
         from .responses_websocket import ResponsesWebSocket
 
         self._client = client
+        self._turn_state = _turn_state
         self.websocket = ResponsesWebSocket(client)
 
+    @contextmanager
+    def turn(self) -> Iterator[Responses]:
+        """Yield isolated HTTP Responses routing for one logical agent turn.
+
+        Reuse this resource for generations/retries within that turn, not across
+        turns. No routing token is persisted or placed in the model's input.
+        Compaction is a separate backend turn and does not inherit this state.
+        """
+        state = ResponsesTurnState()
+        try:
+            yield Responses(self._client, _turn_state=state)
+        finally:
+            state.close()
+
     def create(
         self,
         *,
@@ -113,15 +146,50 @@ class Responses:
         payload = dict(request.payload)
         if extra_body:
             payload.update(_jsonable(extra_body))
+        defaults = self._client._session.headers
+        headers = _cache_affinity_headers(payload, extra_headers, defaults) or {}
+        state = self._turn_state
+        if state is not None:
+            def effective_header(name):
+                return header_value(headers, name, header_value(defaults, name))
+
+            # Also invalidate for explicit per-request authentication overrides. Keep
+            # only a fingerprint, never credentials, in this ephemeral routing state.
+            identity = (
+                self._client._auth_revision,
+                sha256(repr((
+                    effective_header("authorization"), effective_header("chatgpt-account-id"),
+                )).encode()).digest(),
+                effective_header("session-id"),
+                payload.get("prompt_cache_key"),
+            )
+            epoch, value = state.prepare(identity)
+            explicit = effective_header(TURN_STATE_HEADER)
+            if explicit is not None:
+                state.capture(epoch, explicit)
+            elif value:
+                headers[TURN_STATE_HEADER] = value
+
         response = self._client._post(
             "/responses",
             body=payload,
             stream=True,
-            headers=extra_headers,
+            headers=headers or None,
             params=extra_query,
             timeout=timeout,
         )
-        events = stream_response_events(response)
+
+        def capture(headers):
+            if state is not None and self._client._auth_revision == identity[0]:
+                state.capture(epoch, header_value(headers, TURN_STATE_HEADER))
+
+        capture(getattr(response, "headers", {}))
+
+        def on_event(event):
+            if event.type == "response.metadata":
+                capture(getattr(event, "headers", None))
+
+        events = stream_response_events(response, on_event=on_event if state is not None else None)
         stream_enabled = bool(stream) if _is_given(stream) else False
 
         if stream_enabled:
@@ -315,7 +383,7 @@ class Responses:
         if not payload["input"] or payload["input"][-1].get("type") != "compaction_trigger":
             payload["input"].append({"type": "compaction_trigger"})
 
-        headers = dict(extra_headers or {})
+        headers = _cache_affinity_headers(payload, extra_headers, self._client._session.headers) or {}
         beta_features = [
             value.strip()
             for value in headers.get("x-codex-beta-features", "").split(",")
@@ -337,20 +405,21 @@ class Responses:
         )
         output: list[Any] = []
         completed: dict[str, Any] = {}
-        for event in stream_response_events(response):
-            if event.type == "response.output_item.done":
-                item = getattr(event, "item", None)
-                if isinstance(item, dict):
-                    output.append(item)
-            elif event.type == "response.completed":
-                completed_value = getattr(event, "response", None) or {}
-                completed = (
-                    completed_value
-                    if isinstance(completed_value, dict)
-                    else completed_value.model_dump()
-                )
-            elif event.type in {"response.failed", "error"}:
-                raise RuntimeError("Remote compaction v2 failed")
+        with stream_response_events(response) as events:
+            for event in events:
+                if event.type == "response.output_item.done":
+                    item = getattr(event, "item", None)
+                    if isinstance(item, dict):
+                        output.append(item)
+                elif event.type == "response.completed":
+                    completed_value = getattr(event, "response", None) or {}
+                    completed = (
+                        completed_value
+                        if isinstance(completed_value, dict)
+                        else completed_value.model_dump()
+                    )
+                elif event.type in {"response.failed", "error"}:
+                    raise RuntimeError(f"Remote compaction v2 failed: {_event_error_message(event)}")
 
         compaction_items = [item for item in output if item.get("type") == "compaction"]
         if len(compaction_items) != 1:

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/docs/api-reference.md

@@ -110,6 +110,12 @@ Supported backend fields are `input`, `model`, `instructions`, `include`,
 iterator; otherwise the SDK collects the mandatory backend SSE stream into a
 typed `Response`.
 
+For HTTP `create`, `parse` and `compact` requests, a nonempty `prompt_cache_key`
+also supplies the `session-id` header used by the ChatGPT backend for cache
+affinity. An explicit `session-id` in `extra_headers` takes precedence
+(case-insensitively). This preserves routing identity; it does not guarantee a
+cache hit. WebSocket callers supply session headers at connection time.
+
 The OpenAI-compatible signature also accepts the following names so it can
 reject them clearly: `background`, `context_management`, `conversation`,
 `max_output_tokens`, `max_tool_calls`, `metadata`, `previous_response_id`,

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/docs/backend-api.md

@@ -344,12 +344,18 @@ with client.live.sideband.connect(session_id=live.session.id) as sideband:
 
 For Realtime v3, Codex sends `openai-alpha: quicksilver=v2`, the AVAS query
 parameters `intent=quicksilver&architecture=avas`, and a `gpt-live` session.
-Live WebRTC call-creation probes against the ChatGPT OAuth route validated both
+Earlier WebRTC call-creation probes against the ChatGPT OAuth route accepted
 `gpt-live-1-codex` and `gpt-live-1-boulder-alpha`: each returned an SDP answer
-and a Realtime call id. The aliases `gpt-live`, `gpt-live-1`,
-`gpt-live-latest`, and an unknown suffix returned HTTP 400. `create_v3`
-therefore accepts exactly the two confirmed identifiers rather than every
-`gpt-live` prefix.
+and a Realtime call id. Some other identifiers returned HTTP 400 at that time.
+The SDK does not encode these observations as an allowlist: `create_v3` forwards
+model identifiers unchanged and preserves backend errors. Availability depends
+on the account and backend rollout.
+
+On October 22, 2026, a `gpt-live-1.1` probe returned an SDP answer and opened the
+WebRTC data channel using a synthetic silent audio track (no microphone).
+The server subsequently emitted `forbidden: Voice session access denied.`
+No model reply was received; successful call creation is not proof of voice
+session authorization.
 
 This is distinct from the public Realtime API documented for developer API keys.
 On the OpenAI API host, the same Codex implementation uses `/v1/live` for the

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-backend-sdk"
-version = "0.5.3"
+version = "0.5.5"
 description = "Unofficial Python SDK for the ChatGPT Codex backend API"
 readme = "README.md"
 license = { text = "MIT" }

{codex_backend_sdk-0.5.3 → codex_backend_sdk-0.5.5}/tests/test_client_retry.py

@@ -73,8 +73,10 @@ def test_retry_does_not_retry_client_errors(monkeypatch):
 
     try:
         client._get_raw("/models")
-    except requests.HTTPError:
-        pass
+    except requests.HTTPError as error:
+        assert 'Backend response: {"error": "bad request"}' in str(error)
+        assert error.response is not None
+        assert error.response.status_code == 400
     else:
         raise AssertionError("Expected HTTPError")
 
@@ -82,6 +84,21 @@ def test_retry_does_not_retry_client_errors(monkeypatch):
     assert sleeps == []
 
 
+def test_http_error_detail_is_bounded():
+    body = b"x" * 5_000
+    client = RetryClient([_response(400, body=body)])
+
+    try:
+        client._get_raw("/models")
+    except requests.HTTPError as error:
+        message = str(error)
+        assert "Backend response: " in message
+        assert message.endswith("...")
+        assert len(message) < 4_200
+    else:
+        raise AssertionError("Expected HTTPError")
+
+
 def test_retry_retries_transport_timeout(monkeypatch):
     sleeps = []
     monkeypatch.setattr(transport_module.time, "sleep", sleeps.append)