codex-backend-sdk 0.3.8__tar.gz → 0.3.10__tar.gz

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.10] - 2026-07-17
+
+### Added
+- Added typed Codex rate-limit reset credit listing and explicit idempotent consumption through `client.codex.rate_limit_reset_credits`.
+- Added ChatGPT-authenticated image generation and editing through `client.images.generate(...)` and `client.images.edit(...)`, returning typed base64 image data from the Codex backend.
+
+### Documentation
+- Documented that image generation uses the ChatGPT Codex backend rather than the separately billed Platform image endpoint, and that consuming reset credits mutates account quota state.
+- Documented the verified Codex JSON image-edit contract using ordinary URLs or base64 data URLs.
+
+### Tests
+- Added behavioral coverage for credit payloads, redemption validation, image request construction, defaults, URL normalization, and typed responses; verified read-only credit listing plus real image generation and editing against the authenticated backend.
+
+## [0.3.9] - 2026-07-17
+
+### Fixed
+- Detect anonymous audio buffers by their file signature before ChatGPT transcription uploads, correcting filenames and MIME types when callers provide misleading generic names such as `audio.mp3` for WAV data.
+- Restored reliable `AIClient.audio_to_text(bytes)` integration with `/backend-api/transcribe` without requiring callers to understand multipart backend constraints.
+
+### Tests
+- Added regression coverage for WAV buffers carrying an incorrect `.mp3` name and verified the complete Codex Agent transcription path against the real ChatGPT backend.
+
 ## [0.3.8] - 2026-07-17
 
 ### Changed

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-backend-sdk
-Version: 0.3.8
+Version: 0.3.10
 Summary: Unofficial Python SDK for the ChatGPT Codex backend API
 License: MIT
 License-File: LICENSE
@@ -190,6 +190,10 @@ resources (`responses`, `models`, `realtime`) or Codex-only resources (`codex`).
 | `wss://api.openai.com/v1/realtime?model=...` | `client.realtime_websocket_url(...)` / `client.realtime.websocket_headers(...)` | Voice v2 helpers; requires a Realtime API key obtained during OAuth or supplied by the auth store. |
 | `POST /v1/embeddings` | `client.embeddings.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; usage is charged to the associated OpenAI Platform organization. |
 | `POST /backend-api/transcribe` | `client.audio.transcriptions.create(...)` | Uses the authenticated ChatGPT backend for non-streaming batch transcription; no developer API key is required. |
+| `POST /backend-api/codex/images/generations` | `client.images.generate(...)` | Generates images through the authenticated Codex backend and returns typed base64 image data. |
+| `POST /backend-api/codex/images/edits` | `client.images.edit(...)` | Edits one or more URL/data-URL images through the authenticated Codex backend. |
+| `GET /backend-api/codex/rate-limit-reset-credits` | `client.codex.rate_limit_reset_credits.list()` | Lists detailed reset credits available to the authenticated account. |
+| `POST /backend-api/codex/rate-limit-reset-credits/consume` | `client.codex.rate_limit_reset_credits.consume(...)` | Consumes a reset credit using an idempotent redemption request ID. |
 | `GET /backend-api/wham/usage` | `client.codex.usage()` | Codex/ChatGPT quota and rate-limit status. |
 | `GET /backend-api/wham/config/requirements` | `client.codex.config.requirements()` | Raw managed requirements/config payload for the authenticated account. |
 | `GET /backend-api/wham/tasks/list` | `client.codex.tasks.list(...)` | Raw Codex cloud task listing. |
@@ -395,6 +399,34 @@ with open("meeting.wav", "rb") as audio:
 print(transcription.text)
 ```
 
+### Image Generation
+
+`client.images.generate(...)` uses the ChatGPT-authenticated Codex image backend,
+not the separately billed OpenAI Platform image endpoint.
+
+```python
+image = client.images.generate(
+    prompt="A cheerful blue robot holding a red flower",
+    model="gpt-image-2",
+    quality="auto",
+    size="auto",
+)
+
+with open("robot.png", "wb") as output:
+    output.write(base64.b64decode(image.data[0].b64_json))
+```
+
+The Codex contract supports `prompt`, `model`, `background`, `n`, `quality`,
+and `size`. Editing accepts one or more ordinary URLs or data URLs:
+
+```python
+edited = client.images.edit(
+    images=["data:image/png;base64,..."],
+    prompt="Add a small red star in the center",
+    quality="low",
+)
+```
+
 ### Quota And Usage
 
 `client.codex.usage()` calls the ChatGPT WHAM usage endpoint. It returns the raw
@@ -417,6 +449,20 @@ Typical fields include:
 - `credits`
 - `rate_limit_reached_type`
 
+Detailed reset credits are available separately:
+
+```python
+credits = client.codex.rate_limit_reset_credits.list()
+for credit in credits.credits:
+    print(credit.id, credit.title, credit.expires_at)
+
+# Consuming a credit is an account mutation. Use a unique idempotency key.
+result = client.codex.rate_limit_reset_credits.consume(
+    redeem_request_id=str(uuid.uuid4()),
+    credit_id=credits.credits[0].id,
+)
+```
+
 ### Codex Cloud Tasks
 
 The `client.codex.tasks` and `client.codex.environments` namespaces expose

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/README.md

@@ -164,6 +164,10 @@ resources (`responses`, `models`, `realtime`) or Codex-only resources (`codex`).
 | `wss://api.openai.com/v1/realtime?model=...` | `client.realtime_websocket_url(...)` / `client.realtime.websocket_headers(...)` | Voice v2 helpers; requires a Realtime API key obtained during OAuth or supplied by the auth store. |
 | `POST /v1/embeddings` | `client.embeddings.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; usage is charged to the associated OpenAI Platform organization. |
 | `POST /backend-api/transcribe` | `client.audio.transcriptions.create(...)` | Uses the authenticated ChatGPT backend for non-streaming batch transcription; no developer API key is required. |
+| `POST /backend-api/codex/images/generations` | `client.images.generate(...)` | Generates images through the authenticated Codex backend and returns typed base64 image data. |
+| `POST /backend-api/codex/images/edits` | `client.images.edit(...)` | Edits one or more URL/data-URL images through the authenticated Codex backend. |
+| `GET /backend-api/codex/rate-limit-reset-credits` | `client.codex.rate_limit_reset_credits.list()` | Lists detailed reset credits available to the authenticated account. |
+| `POST /backend-api/codex/rate-limit-reset-credits/consume` | `client.codex.rate_limit_reset_credits.consume(...)` | Consumes a reset credit using an idempotent redemption request ID. |
 | `GET /backend-api/wham/usage` | `client.codex.usage()` | Codex/ChatGPT quota and rate-limit status. |
 | `GET /backend-api/wham/config/requirements` | `client.codex.config.requirements()` | Raw managed requirements/config payload for the authenticated account. |
 | `GET /backend-api/wham/tasks/list` | `client.codex.tasks.list(...)` | Raw Codex cloud task listing. |
@@ -369,6 +373,34 @@ with open("meeting.wav", "rb") as audio:
 print(transcription.text)
 ```
 
+### Image Generation
+
+`client.images.generate(...)` uses the ChatGPT-authenticated Codex image backend,
+not the separately billed OpenAI Platform image endpoint.
+
+```python
+image = client.images.generate(
+    prompt="A cheerful blue robot holding a red flower",
+    model="gpt-image-2",
+    quality="auto",
+    size="auto",
+)
+
+with open("robot.png", "wb") as output:
+    output.write(base64.b64decode(image.data[0].b64_json))
+```
+
+The Codex contract supports `prompt`, `model`, `background`, `n`, `quality`,
+and `size`. Editing accepts one or more ordinary URLs or data URLs:
+
+```python
+edited = client.images.edit(
+    images=["data:image/png;base64,..."],
+    prompt="Add a small red star in the center",
+    quality="low",
+)
+```
+
 ### Quota And Usage
 
 `client.codex.usage()` calls the ChatGPT WHAM usage endpoint. It returns the raw
@@ -391,6 +423,20 @@ Typical fields include:
 - `credits`
 - `rate_limit_reached_type`
 
+Detailed reset credits are available separately:
+
+```python
+credits = client.codex.rate_limit_reset_credits.list()
+for credit in credits.credits:
+    print(credit.id, credit.title, credit.expires_at)
+
+# Consuming a credit is an account mutation. Use a unique idempotency key.
+result = client.codex.rate_limit_reset_credits.consume(
+    redeem_request_id=str(uuid.uuid4()),
+    credit_id=credits.credits[0].id,
+)
+```
+
 ### Codex Cloud Tasks
 
 The `client.codex.tasks` and `client.codex.environments` namespaces expose

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/__init__.py

@@ -17,7 +17,7 @@ Quickstart:
     print(response.output_text)
 """
 
-__version__ = "0.3.8"
+__version__ = "0.3.10"
 
 from .oauth import run_oauth_flow, refresh_access_token
 from .storage import load_tokens, save_tokens, TokenStore
@@ -27,6 +27,11 @@ from .codex_client import (
     CreateEmbeddingResponse,
     Embedding,
     EmbeddingUsage,
+    ImageData,
+    ImageResponse,
+    RateLimitResetCredit,
+    RateLimitResetCredits,
+    ConsumeRateLimitResetCreditResponse,
     ReasoningEffort,
     ReasoningSummary,
     ServiceTier,
@@ -60,6 +65,11 @@ __all__ = [
     "CreateEmbeddingResponse",
     "Embedding",
     "EmbeddingUsage",
+    "ImageData",
+    "ImageResponse",
+    "RateLimitResetCredit",
+    "RateLimitResetCredits",
+    "ConsumeRateLimitResetCreditResponse",
     "MemorySummarizeOutput",
     "MemorySummarizeResponse",
     "Model",

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/_client.py

@@ -40,6 +40,7 @@ class CodexClient:
         from .resources.models import Models
         from .resources.openai_oauth import Audio, Embeddings
         from .resources.files import Files
+        from .resources.images import Images
         from .resources.realtime import Realtime
         from .resources.responses import Responses
 
@@ -59,6 +60,7 @@ class CodexClient:
         self.realtime = Realtime(self)
         self.embeddings = Embeddings(self)
         self.audio = Audio(self)
+        self.images = Images(self)
         self.files = Files(self)
         self.codex = CodexResources(self)
 

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/_models.py

@@ -225,6 +225,39 @@ class Transcription(CodexBaseModel):
     text: str = ""
 
 
+class ImageData(CodexBaseModel):
+    b64_json: str
+
+
+class ImageResponse(CodexBaseModel):
+    created: int
+    data: list[ImageData] = Field(default_factory=list)
+    background: Optional[str] = None
+    quality: Optional[str] = None
+    size: Optional[str] = None
+
+
+class RateLimitResetCredit(CodexBaseModel):
+    id: str
+    reset_type: str
+    status: str
+    granted_at: str
+    expires_at: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+
+
+class RateLimitResetCredits(CodexBaseModel):
+    available_count: int = 0
+    total_earned_count: int = 0
+    credits: list[RateLimitResetCredit] = Field(default_factory=list)
+
+
+class ConsumeRateLimitResetCreditResponse(CodexBaseModel):
+    code: str
+    windows_reset: int = 0
+
+
 class RawMemoryMetadata(CodexBaseModel):
     source_path: str
 

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/codex_client.py

@@ -13,12 +13,17 @@ from ._models import (
     CreateEmbeddingResponse,
     Embedding,
     EmbeddingUsage,
+    ImageData,
+    ImageResponse,
     Model,
     MemorySummarizeOutput,
     MemorySummarizeResponse,
     ParsedResponse,
     RawMemory,
     RawMemoryMetadata,
+    RateLimitResetCredit,
+    RateLimitResetCredits,
+    ConsumeRateLimitResetCreditResponse,
     ReasoningEffort,
     ReasoningSummary,
     RealtimeCallResponse,
@@ -42,6 +47,8 @@ __all__ = [
     "CreateEmbeddingResponse",
     "Embedding",
     "EmbeddingUsage",
+    "ImageData",
+    "ImageResponse",
     "CompactedResponse",
     "MemorySummarizeOutput",
     "MemorySummarizeResponse",
@@ -50,6 +57,9 @@ __all__ = [
     "ParsedResponse",
     "RawMemory",
     "RawMemoryMetadata",
+    "RateLimitResetCredit",
+    "RateLimitResetCredits",
+    "ConsumeRateLimitResetCreditResponse",
     "ReasoningEffort",
     "ReasoningSummary",
     "Response",

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/resources/codex.py

@@ -4,7 +4,11 @@ from __future__ import annotations
 
 from typing import Any, TYPE_CHECKING
 
-from .._models import MemorySummarizeResponse
+from .._models import (
+    ConsumeRateLimitResetCreditResponse,
+    MemorySummarizeResponse,
+    RateLimitResetCredits,
+)
 from .._utils import _jsonable
 
 if TYPE_CHECKING:
@@ -20,12 +24,48 @@ class CodexResources:
         self.tasks = CodexTasks(client)
         self.environments = CodexEnvironments(client)
         self.config = CodexConfig(client)
+        self.rate_limit_reset_credits = CodexRateLimitResetCredits(client)
         self.user_system_messages = CodexUserSystemMessages(client)
 
     def usage(self) -> dict[str, Any]:
         return self._client._get_wham("/wham/usage")
 
 
+class CodexRateLimitResetCredits:
+    """Detailed Codex rate-limit reset credits for the authenticated account."""
+
+    def __init__(self, client: CodexClient) -> None:
+        self._client = client
+
+    def list(self) -> RateLimitResetCredits:
+        return RateLimitResetCredits.model_validate(
+            self._client._get("/rate-limit-reset-credits")
+        )
+
+    def consume(
+        self,
+        *,
+        redeem_request_id: str,
+        credit_id: str | None = None,
+    ) -> ConsumeRateLimitResetCreditResponse:
+        if not redeem_request_id:
+            raise ValueError(
+                "Expected a non-empty value for `redeem_request_id` "
+                f"but received {redeem_request_id!r}"
+            )
+        if credit_id == "":
+            raise ValueError("Expected `credit_id` to be non-empty when provided")
+        payload = {"redeem_request_id": redeem_request_id}
+        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()
+        )
+
+
 class CodexMemories:
     """ChatGPT memory data for the authenticated account."""
 

codex_backend_sdk-0.3.10/codex_backend_sdk/resources/images.py

@@ -0,0 +1,101 @@
+"""ChatGPT Codex image generation resources."""
+
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+from .._models import ImageResponse
+from .._utils import _UNSET, _add_given, _jsonable
+
+if TYPE_CHECKING:
+    from .._client import CodexClient
+
+
+class Images:
+    """Image generation through the authenticated Codex backend."""
+
+    def __init__(self, client: CodexClient) -> None:
+        self._client = client
+
+    def generate(
+        self,
+        *,
+        prompt: str,
+        model: str = "gpt-image-2",
+        background: Any = _UNSET,
+        n: Any = _UNSET,
+        quality: Any = _UNSET,
+        size: Any = _UNSET,
+        extra_body: Any = None,
+        timeout: Any = _UNSET,
+    ) -> ImageResponse:
+        if not prompt:
+            raise ValueError(f"Expected a non-empty value for `prompt` but received {prompt!r}")
+        if not model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+
+        payload: dict[str, Any] = {"prompt": prompt, "model": model}
+        _add_given(payload, "background", background)
+        _add_given(payload, "n", n)
+        _add_given(payload, "quality", quality)
+        _add_given(payload, "size", size)
+        if extra_body:
+            payload.update(_jsonable(extra_body))
+
+        response = self._client._post_raw(
+            "/images/generations",
+            body=payload,
+            timeout=timeout,
+        )
+        return ImageResponse.model_validate(response.json())
+
+    def edit(
+        self,
+        *,
+        images: list[str | dict[str, str]],
+        prompt: str,
+        model: str = "gpt-image-2",
+        background: Any = _UNSET,
+        n: Any = _UNSET,
+        quality: Any = _UNSET,
+        size: Any = _UNSET,
+        extra_body: Any = None,
+        timeout: Any = _UNSET,
+    ) -> ImageResponse:
+        if not images:
+            raise ValueError("Expected at least one value for `images`")
+        if not prompt:
+            raise ValueError(f"Expected a non-empty value for `prompt` but received {prompt!r}")
+        if not model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+
+        normalized_images = []
+        for image in images:
+            if isinstance(image, str):
+                if not image:
+                    raise ValueError("Expected every image URL to be non-empty")
+                normalized_images.append({"image_url": image})
+                continue
+            image_url = image.get("image_url")
+            if not image_url:
+                raise ValueError("Expected every image object to contain a non-empty `image_url`")
+            normalized_images.append({"image_url": image_url})
+
+        payload: dict[str, Any] = {
+            "images": normalized_images,
+            "prompt": prompt,
+            "model": model,
+        }
+        _add_given(payload, "background", background)
+        _add_given(payload, "n", n)
+        _add_given(payload, "quality", quality)
+        _add_given(payload, "size", size)
+        if extra_body:
+            payload.update(_jsonable(extra_body))
+
+        response = self._client._post_raw(
+            "/images/edits",
+            body=payload,
+            timeout=timeout,
+        )
+        return ImageResponse.model_validate(response.json())

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/codex_backend_sdk/resources/openai_oauth.py

@@ -126,7 +126,7 @@ class AudioTranscriptions:
 
         response = self._client._post_chatgpt_raw(
             "/transcribe",
-            files={"file": _coerce_file(file)},
+            files={"file": _coerce_audio_file(file)},
             data={key: _form_value(value) for key, value in data.items()},
             headers=extra_headers,
             params=extra_query,
@@ -136,3 +136,38 @@ class AudioTranscriptions:
         if _is_given(response_format) and response_format == "text":
             return transcription.text
         return transcription
+
+
+def _coerce_audio_file(file: Any) -> Any:
+    coerced = _coerce_file(file)
+    if isinstance(coerced, tuple):
+        return coerced
+    if not hasattr(coerced, "read"):
+        return coerced
+
+    position = coerced.tell() if hasattr(coerced, "tell") else None
+    header = coerced.read(12)
+    if position is not None and hasattr(coerced, "seek"):
+        coerced.seek(position)
+
+    detected = _audio_type(header)
+    if detected is None:
+        return coerced
+    extension, mime_type = detected
+    name = getattr(coerced, "name", "audio") or "audio"
+    stem = str(name).rsplit("/", 1)[-1].rsplit(".", 1)[0] or "audio"
+    return (f"{stem}.{extension}", coerced, mime_type)
+
+
+def _audio_type(header: bytes) -> tuple[str, str] | None:
+    if header.startswith(b"RIFF") and header[8:12] == b"WAVE":
+        return "wav", "audio/wav"
+    if header.startswith(b"ID3") or header[:2] in {b"\xff\xfb", b"\xff\xf3", b"\xff\xf2"}:
+        return "mp3", "audio/mpeg"
+    if header.startswith(b"OggS"):
+        return "ogg", "audio/ogg"
+    if header.startswith(b"fLaC"):
+        return "flac", "audio/flac"
+    if header[4:8] == b"ftyp":
+        return "m4a", "audio/mp4"
+    return None

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/docs/backend-api.md

@@ -344,6 +344,26 @@ response options used by Codex Agent. Streaming, timestamps, speaker references,
 chunking, SRT, and VTT are rejected locally rather than falling back to a
 billable Platform endpoint.
 
+### `POST /backend-api/codex/images/generations`
+
+**SDK method**: `client.images.generate(...)`
+
+**Status**: Supported through ChatGPT OAuth. Verified with `gpt-image-2`; the
+response contains `created` and `data[].b64_json`, plus optional effective
+`background`, `quality`, and `size` fields. Supported request fields mirror the
+current Codex client: `prompt`, `model`, `background`, `n`, `quality`, and
+`size`. This uses the Codex/ChatGPT backend rather than the OpenAI Platform
+image endpoint.
+
+### `POST /backend-api/codex/images/edits`
+
+**SDK method**: `client.images.edit(...)`
+
+**Status**: Supported through ChatGPT OAuth. Accepts one or more remote URLs or
+`data:` URLs as `images[].image_url`, plus the same prompt/model/background/count/
+quality/size controls as generation. Verified by generating a source image and
+editing it through the authenticated backend.
+
 ### `POST /v1/audio/speech`
 
 **Status**: Observed but not exposed. A malformed request reaches payload
@@ -389,6 +409,24 @@ Known `rate_limit_reached_type.type` values: `rate_limit_reached`, `workspace_ow
 
 ---
 
+### `GET /backend-api/codex/rate-limit-reset-credits`
+
+**SDK method**: `client.codex.rate_limit_reset_credits.list()`
+
+Returns a typed detail payload containing `available_count`,
+`total_earned_count`, and credit rows with IDs, reset type, status, grant and
+expiry timestamps, title, and description. The equivalent WHAM path is also
+currently accepted by ChatGPT, but the SDK follows the active Codex client
+path.
+
+### `POST /backend-api/codex/rate-limit-reset-credits/consume`
+
+**SDK method**: `client.codex.rate_limit_reset_credits.consume(...)`
+
+Consumes a reset credit. `redeem_request_id` is required as the idempotency key;
+`credit_id` selects a specific available credit when supplied. This mutates
+account quota state and is never called implicitly by the SDK.
+
 ### `GET /backend-api/wham/config/requirements`
 
 Fetch managed requirements/config for this account (plan-gated settings).

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/pyproject.toml

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

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/tests/test_codex_resources.py

@@ -1,4 +1,12 @@
-from codex_backend_sdk import MemorySummarizeResponse, OpenAI, RawMemory
+import pytest
+
+from codex_backend_sdk import (
+    ConsumeRateLimitResetCreditResponse,
+    MemorySummarizeResponse,
+    OpenAI,
+    RateLimitResetCredits,
+    RawMemory,
+)
 
 
 class FakeCodexClient(OpenAI):
@@ -26,6 +34,22 @@ class FakeCodexClient(OpenAI):
             return [{"id": "env_1", "label": "default"}]
         raise AssertionError(f"Unexpected WHAM path: {path}")
 
+    def _get(self, path, *, params=None):
+        if path == "/rate-limit-reset-credits":
+            return {
+                "available_count": 1,
+                "total_earned_count": 2,
+                "credits": [{
+                    "id": "credit_1",
+                    "reset_type": "codex_rate_limits",
+                    "status": "available",
+                    "granted_at": "2026-07-01T00:00:00Z",
+                    "expires_at": "2026-08-01T00:00:00Z",
+                    "title": "Full reset",
+                }],
+            }
+        raise AssertionError(f"Unexpected Codex get path: {path}")
+
     def _get_chatgpt(self, path):
         self.chatgpt_gets.append(path)
         if path == "/memories":
@@ -44,6 +68,8 @@ class FakeCodexClient(OpenAI):
             return FakeJSONResponse({
                 "output": [{"trace_summary": "raw", "memory_summary": "summary"}]
             })
+        if path == "/rate-limit-reset-credits/consume":
+            return FakeJSONResponse({"code": "reset", "windows_reset": 2})
         raise AssertionError(f"Unexpected Codex post path: {path}")
 
 
@@ -64,6 +90,50 @@ def test_codex_usage_still_calls_wham_usage():
     assert client.wham_gets == [("/wham/usage", None)]
 
 
+def test_codex_rate_limit_reset_credits_list_returns_typed_details():
+    client = FakeCodexClient()
+
+    result = client.codex.rate_limit_reset_credits.list()
+
+    assert isinstance(result, RateLimitResetCredits)
+    assert result.available_count == 1
+    assert result.total_earned_count == 2
+    assert result.credits[0].id == "credit_1"
+    assert result.credits[0].title == "Full reset"
+
+
+def test_codex_rate_limit_reset_credits_consume_posts_idempotency_and_credit_ids():
+    client = FakeCodexClient()
+
+    result = client.codex.rate_limit_reset_credits.consume(
+        redeem_request_id="redeem_1",
+        credit_id="credit_1",
+    )
+
+    assert isinstance(result, ConsumeRateLimitResetCreditResponse)
+    assert result.code == "reset"
+    assert result.windows_reset == 2
+    assert client.posts == [
+        (
+            "/rate-limit-reset-credits/consume",
+            {"redeem_request_id": "redeem_1", "credit_id": "credit_1"},
+            False,
+        )
+    ]
+
+
+def test_codex_rate_limit_reset_credits_rejects_empty_identifiers():
+    client = FakeCodexClient()
+
+    with pytest.raises(ValueError, match="redeem_request_id"):
+        client.codex.rate_limit_reset_credits.consume(redeem_request_id="")
+    with pytest.raises(ValueError, match="credit_id"):
+        client.codex.rate_limit_reset_credits.consume(
+            redeem_request_id="redeem_1",
+            credit_id="",
+        )
+
+
 def test_codex_memories_list_returns_raw_chatgpt_payload():
     client = FakeCodexClient()
 

codex_backend_sdk-0.3.10/tests/test_images.py

@@ -0,0 +1,132 @@
+import pytest
+
+from codex_backend_sdk import ImageResponse, OpenAI
+
+
+class FakeJSONResponse:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def json(self):
+        return self._payload
+
+
+class FakeImagesClient(OpenAI):
+    def __init__(self):
+        super().__init__(model="gpt-test")
+        self.posts = []
+
+    def _post_raw(self, path, **kwargs):
+        self.posts.append((path, kwargs))
+        return FakeJSONResponse({
+            "created": 1,
+            "data": [{"b64_json": "aW1hZ2U="}],
+            "background": "opaque",
+            "quality": "medium",
+            "size": "1024x1024",
+        })
+
+
+def test_images_generate_posts_codex_payload_and_returns_typed_response():
+    client = FakeImagesClient()
+
+    response = client.images.generate(
+        prompt="a cheerful blue robot",
+        background="opaque",
+        n=1,
+        quality="medium",
+        size="1024x1024",
+        extra_body={"custom": {"enabled": True}},
+        timeout=180,
+    )
+
+    assert isinstance(response, ImageResponse)
+    assert response.data[0].b64_json == "aW1hZ2U="
+    assert response.background == "opaque"
+    assert client.posts == [
+        (
+            "/images/generations",
+            {
+                "body": {
+                    "prompt": "a cheerful blue robot",
+                    "model": "gpt-image-2",
+                    "background": "opaque",
+                    "n": 1,
+                    "quality": "medium",
+                    "size": "1024x1024",
+                    "custom": {"enabled": True},
+                },
+                "timeout": 180,
+            },
+        )
+    ]
+
+
+def test_images_edit_normalizes_urls_and_posts_codex_payload():
+    client = FakeImagesClient()
+
+    response = client.images.edit(
+        images=[
+            "data:image/png;base64,aW1hZ2U=",
+            {"image_url": "https://example.test/reference.png"},
+        ],
+        prompt="add a red star",
+        quality="low",
+        timeout=240,
+    )
+
+    assert isinstance(response, ImageResponse)
+    assert client.posts == [
+        (
+            "/images/edits",
+            {
+                "body": {
+                    "images": [
+                        {"image_url": "data:image/png;base64,aW1hZ2U="},
+                        {"image_url": "https://example.test/reference.png"},
+                    ],
+                    "prompt": "add a red star",
+                    "model": "gpt-image-2",
+                    "quality": "low",
+                },
+                "timeout": 240,
+            },
+        )
+    ]
+
+
+@pytest.mark.parametrize(
+    "images, match",
+    [
+        ([], "at least one"),
+        ([""], "non-empty"),
+        ([{}], "image_url"),
+    ],
+)
+def test_images_edit_rejects_invalid_images(images, match):
+    client = FakeImagesClient()
+
+    with pytest.raises(ValueError, match=match):
+        client.images.edit(images=images, prompt="add a star")
+
+
+def test_images_generate_uses_minimal_default_payload():
+    client = FakeImagesClient()
+
+    client.images.generate(prompt="a red flower")
+
+    _, kwargs = client.posts[0]
+    assert kwargs["body"] == {
+        "prompt": "a red flower",
+        "model": "gpt-image-2",
+    }
+
+
+@pytest.mark.parametrize("field", ["prompt", "model"])
+def test_images_generate_rejects_empty_required_fields(field):
+    client = FakeImagesClient()
+    arguments = {"prompt": "a red flower", "model": "gpt-image-2"}
+    arguments[field] = ""
+
+    with pytest.raises(ValueError, match=field):
+        client.images.generate(**arguments)

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/tests/test_openai_oauth_resources.py

@@ -1,3 +1,5 @@
+from io import BytesIO
+
 import pytest
 
 from codex_backend_sdk import CreateEmbeddingResponse, OpenAI, Transcription
@@ -92,6 +94,24 @@ def test_audio_transcriptions_create_posts_to_chatgpt_backend():
     assert headers["ChatGPT-Account-ID"] == "account-id"
 
 
+def test_audio_transcriptions_detects_anonymous_audio_format():
+    client = FakeOpenAIClient()
+    audio = BytesIO(b"RIFF\x00\x00\x00\x00WAVEfmt ")
+    audio.name = "audio.mp3"
+
+    client.audio.transcriptions.create(
+        model="gpt-4o-mini-transcribe",
+        file=audio,
+    )
+
+    _, kwargs, _ = client.chatgpt_raw_posts[0]
+    filename, uploaded, mime_type = kwargs["files"]["file"]
+    assert filename == "audio.wav"
+    assert uploaded is audio
+    assert mime_type == "audio/wav"
+    assert audio.tell() == 0
+
+
 def test_audio_transcriptions_text_format_returns_string():
     client = FakeOpenAIClient()
 

{codex_backend_sdk-0.3.8 → codex_backend_sdk-0.3.10}/uv.lock

@@ -160,7 +160,7 @@ wheels = [
 
 [[package]]
 name = "codex-backend-sdk"
-version = "0.3.8"
+version = "0.3.10"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },