codex-backend-sdk 0.3.0__tar.gz → 0.3.1__tar.gz

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-backend-sdk
-Version: 0.3.0
+Version: 0.3.1
 Summary: Unofficial Python SDK for the ChatGPT Codex backend API
 License: MIT
 License-File: LICENSE
@@ -184,17 +184,20 @@ resources (`responses`, `models`, `realtime`) or Codex-only resources (`codex`).
 |---|---|---|
 | `POST /backend-api/codex/responses` | `client.responses.create(...)` | Stream-only backend; non-streaming SDK calls are collected from SSE events. |
 | `POST /backend-api/codex/responses/compact` | `client.responses.compact(...)` | Codex-specific helper for encrypted context compaction. |
+| `POST /backend-api/codex/memories/trace_summarize` | `client.codex.memories.trace_summarize(...)` | Raw Codex memory trace summarization helper. |
 | `GET /backend-api/codex/models` | `client.models.list()` / `client.models.retrieve(...)` | OpenAI-shaped model objects with Codex metadata preserved as extra fields. |
 | `POST /backend-api/codex/realtime/calls` | `client.realtime.calls.create(...)` | OpenAI-shaped SDP call creation for realtime sessions. |
 | `wss://api.openai.com/v1/realtime?model=...` | `client.realtime_websocket_url(...)` / `client.realtime_websocket_headers(...)` | Helper surface used by codex-agent's realtime plugin. |
 | `POST /v1/embeddings` | `client.embeddings.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; verified with `text-embedding-3-small`. |
 | `POST /v1/audio/transcriptions` | `client.audio.transcriptions.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; verified with `gpt-4o-mini-transcribe`. |
 | `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. |
 | `GET /backend-api/wham/tasks/{task_id}` | `client.codex.tasks.retrieve(task_id)` | Raw Codex cloud task detail. |
 | `GET /backend-api/wham/tasks/{task_id}/turns` | `client.codex.tasks.turns.list(task_id)` | Raw task turn mapping. |
 | `GET /backend-api/wham/tasks/{task_id}/turns/{turn_id}/sibling_turns` | `client.codex.tasks.turns.sibling_turns(task_id, turn_id)` | Raw sibling turn list. |
 | `GET /backend-api/wham/environments` | `client.codex.environments.list()` | Raw Codex cloud environment list. |
+| `POST /backend-api/files` + signed upload | `client.files.upload(...)` | Uploads local files for Codex Apps/MCP file parameters and returns `sediment://...` metadata. |
 | `GET /backend-api/memories` | `client.codex.memories.list()` | Raw ChatGPT memory payload for the authenticated account. |
 | `GET /backend-api/user_system_messages` | `client.codex.user_system_messages.retrieve()` | Raw ChatGPT customization/system-message payload. |
 
@@ -403,18 +406,46 @@ not part of the official OpenAI SDK.
 ```python
 memories = client.codex.memories.list()
 customization = client.codex.user_system_messages.retrieve()
+requirements = client.codex.config.requirements()
 ```
 
-Both methods return raw backend dictionaries because these payloads can contain
+These methods return raw backend dictionaries because these payloads can contain
 personal account-specific fields and may change without notice.
 
+`client.codex.memories.trace_summarize(...)` exposes the Codex memory
+summarization endpoint used by the official client. It returns the raw backend
+dictionary:
+
+```python
+summary = client.codex.memories.trace_summarize(
+    model="gpt-5.4",
+    traces=[
+        {
+            "id": "trace_1",
+            "metadata": {"source_path": "memory.jsonl"},
+            "items": [{"type": "message", "content": "Remember this"}],
+        }
+    ],
+    reasoning={"effort": "low"},
+)
+```
+
+### File Uploads
+
+`client.files.upload(...)` follows the official Codex file flow for Apps/MCP
+file parameters: create file metadata under ChatGPT, upload bytes to the signed
+URL, then finalize the upload.
+
+```python
+uploaded = client.files.upload("report.csv")
+print(uploaded.uri)  # sediment://file_...
+```
+
 ### Observed But Not Exposed
 
 The reverse-engineering notes in `docs/backend-api.md` include additional
 observed endpoints. They are not exposed as SDK resources yet because they are
 plan-gated, unavailable on `chatgpt.com`, or not stable enough:
 
-- `POST /backend-api/codex/memories/trace_summarize`
-- `GET /backend-api/wham/config/requirements`
 - `POST /v1/audio/speech` (auth reaches the endpoint, but Pro OAuth lacks
   `api.model.audio.request` in current tests)

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/README.md

@@ -158,17 +158,20 @@ resources (`responses`, `models`, `realtime`) or Codex-only resources (`codex`).
 |---|---|---|
 | `POST /backend-api/codex/responses` | `client.responses.create(...)` | Stream-only backend; non-streaming SDK calls are collected from SSE events. |
 | `POST /backend-api/codex/responses/compact` | `client.responses.compact(...)` | Codex-specific helper for encrypted context compaction. |
+| `POST /backend-api/codex/memories/trace_summarize` | `client.codex.memories.trace_summarize(...)` | Raw Codex memory trace summarization helper. |
 | `GET /backend-api/codex/models` | `client.models.list()` / `client.models.retrieve(...)` | OpenAI-shaped model objects with Codex metadata preserved as extra fields. |
 | `POST /backend-api/codex/realtime/calls` | `client.realtime.calls.create(...)` | OpenAI-shaped SDP call creation for realtime sessions. |
 | `wss://api.openai.com/v1/realtime?model=...` | `client.realtime_websocket_url(...)` / `client.realtime_websocket_headers(...)` | Helper surface used by codex-agent's realtime plugin. |
 | `POST /v1/embeddings` | `client.embeddings.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; verified with `text-embedding-3-small`. |
 | `POST /v1/audio/transcriptions` | `client.audio.transcriptions.create(...)` | Uses the Codex OAuth access token against `api.openai.com`; verified with `gpt-4o-mini-transcribe`. |
 | `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. |
 | `GET /backend-api/wham/tasks/{task_id}` | `client.codex.tasks.retrieve(task_id)` | Raw Codex cloud task detail. |
 | `GET /backend-api/wham/tasks/{task_id}/turns` | `client.codex.tasks.turns.list(task_id)` | Raw task turn mapping. |
 | `GET /backend-api/wham/tasks/{task_id}/turns/{turn_id}/sibling_turns` | `client.codex.tasks.turns.sibling_turns(task_id, turn_id)` | Raw sibling turn list. |
 | `GET /backend-api/wham/environments` | `client.codex.environments.list()` | Raw Codex cloud environment list. |
+| `POST /backend-api/files` + signed upload | `client.files.upload(...)` | Uploads local files for Codex Apps/MCP file parameters and returns `sediment://...` metadata. |
 | `GET /backend-api/memories` | `client.codex.memories.list()` | Raw ChatGPT memory payload for the authenticated account. |
 | `GET /backend-api/user_system_messages` | `client.codex.user_system_messages.retrieve()` | Raw ChatGPT customization/system-message payload. |
 
@@ -377,18 +380,46 @@ not part of the official OpenAI SDK.
 ```python
 memories = client.codex.memories.list()
 customization = client.codex.user_system_messages.retrieve()
+requirements = client.codex.config.requirements()
 ```
 
-Both methods return raw backend dictionaries because these payloads can contain
+These methods return raw backend dictionaries because these payloads can contain
 personal account-specific fields and may change without notice.
 
+`client.codex.memories.trace_summarize(...)` exposes the Codex memory
+summarization endpoint used by the official client. It returns the raw backend
+dictionary:
+
+```python
+summary = client.codex.memories.trace_summarize(
+    model="gpt-5.4",
+    traces=[
+        {
+            "id": "trace_1",
+            "metadata": {"source_path": "memory.jsonl"},
+            "items": [{"type": "message", "content": "Remember this"}],
+        }
+    ],
+    reasoning={"effort": "low"},
+)
+```
+
+### File Uploads
+
+`client.files.upload(...)` follows the official Codex file flow for Apps/MCP
+file parameters: create file metadata under ChatGPT, upload bytes to the signed
+URL, then finalize the upload.
+
+```python
+uploaded = client.files.upload("report.csv")
+print(uploaded.uri)  # sediment://file_...
+```
+
 ### Observed But Not Exposed
 
 The reverse-engineering notes in `docs/backend-api.md` include additional
 observed endpoints. They are not exposed as SDK resources yet because they are
 plan-gated, unavailable on `chatgpt.com`, or not stable enough:
 
-- `POST /backend-api/codex/memories/trace_summarize`
-- `GET /backend-api/wham/config/requirements`
 - `POST /v1/audio/speech` (auth reaches the endpoint, but Pro OAuth lacks
   `api.model.audio.request` in current tests)

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/__init__.py

@@ -17,7 +17,7 @@ Quickstart:
     print(response.output_text)
 """
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 from .oauth import run_oauth_flow, refresh_access_token, obtain_api_key
 from .storage import load_tokens, save_tokens, TokenStore
@@ -41,6 +41,7 @@ from .codex_client import (
     SyncPage,
     CompactedResponse,
     Transcription,
+    UploadedFile,
     image_url,
     image_b64,
 )
@@ -61,6 +62,7 @@ __all__ = [
     "SyncPage",
     "CompactedResponse",
     "Transcription",
+    "UploadedFile",
     "ReasoningEffort",
     "ReasoningSummary",
     "ServiceTier",

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/_client.py

@@ -36,6 +36,7 @@ class CodexClient:
         from .resources.codex import CodexResources
         from .resources.models import Models
         from .resources.openai_oauth import Audio, Embeddings
+        from .resources.files import Files
         from .resources.realtime import Realtime
         from .resources.responses import Responses
 
@@ -53,6 +54,7 @@ class CodexClient:
         self.realtime = Realtime(self)
         self.embeddings = Embeddings(self)
         self.audio = Audio(self)
+        self.files = Files(self)
         self.codex = CodexResources(self)
 
     def authenticate(self, *, request_api_key: bool = True) -> "CodexClient":
@@ -140,6 +142,7 @@ class CodexClient:
         self,
         path: str,
         *,
+        body: Optional[dict[str, Any]] = None,
         content: Optional[bytes] = None,
         files: Any = None,
         data: Any = None,
@@ -150,7 +153,8 @@ class CodexClient:
         self._ensure_auth()
         response = self._session.post(
             f"{BASE_URL}{path}",
-            data=content if files is None else data,
+            json=body if files is None and data is None and content is None else None,
+            data=content if content is not None else data,
             files=files,
             headers=headers,
             params=params,
@@ -221,6 +225,22 @@ class CodexClient:
         response.raise_for_status()
         return response.json()
 
+    def _post_chatgpt(
+        self,
+        path: str,
+        *,
+        body: dict[str, Any],
+        timeout: Any = _UNSET,
+    ) -> dict[str, Any]:
+        self._ensure_auth()
+        response = self._session.post(
+            f"{CHATGPT_BASE_URL}{path}",
+            json=body,
+            timeout=self._timeout if not _is_given(timeout) else timeout,
+        )
+        response.raise_for_status()
+        return response.json()
+
     def realtime_websocket_url(self, *, model: str) -> str:
         """Return the official OpenAI Realtime WebSocket URL for Codex plugins."""
         if not model:

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/_models.py

@@ -173,6 +173,16 @@ class Transcription(CodexBaseModel):
     text: str = ""
 
 
+class UploadedFile(CodexBaseModel):
+    file_id: str
+    uri: str
+    download_url: str
+    file_name: str
+    file_size_bytes: int
+    mime_type: Optional[str] = None
+    path: str
+
+
 class CompactedResponse(CodexBaseModel):
     id: str
     object: str = "response.compacted"

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/codex_client.py

@@ -24,6 +24,7 @@ from ._models import (
     SyncPage,
     TokenDetails,
     Transcription,
+    UploadedFile,
     Verbosity,
 )
 from ._utils import CodexBackendUnsupportedParameterError, image_b64, image_url
@@ -48,6 +49,7 @@ __all__ = [
     "SyncPage",
     "TokenDetails",
     "Transcription",
+    "UploadedFile",
     "Verbosity",
     "image_b64",
     "image_url",

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/resources/codex.py

@@ -16,6 +16,7 @@ class CodexResources:
         self.memories = CodexMemories(client)
         self.tasks = CodexTasks(client)
         self.environments = CodexEnvironments(client)
+        self.config = CodexConfig(client)
         self.user_system_messages = CodexUserSystemMessages(client)
 
     def usage(self) -> dict[str, Any]:
@@ -31,6 +32,30 @@ class CodexMemories:
     def list(self) -> dict[str, Any]:
         return self._client._get_chatgpt("/memories")
 
+    def trace_summarize(
+        self,
+        *,
+        model: str,
+        traces: list[dict[str, Any]],
+        reasoning: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if not model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+        payload: dict[str, Any] = {"model": model, "traces": traces}
+        if reasoning is not None:
+            payload["reasoning"] = reasoning
+        return self._client._post("/memories/trace_summarize", body=payload).json()
+
+
+class CodexConfig:
+    """Codex WHAM account configuration resources."""
+
+    def __init__(self, client: CodexClient) -> None:
+        self._client = client
+
+    def requirements(self) -> dict[str, Any]:
+        return self._client._get_wham("/wham/config/requirements")
+
 
 class CodexTasks:
     """Codex cloud task data for the authenticated account."""

codex_backend_sdk-0.3.1/codex_backend_sdk/resources/files.py

@@ -0,0 +1,116 @@
+"""ChatGPT file upload helpers used by Codex Apps tools."""
+
+from __future__ import annotations
+
+import mimetypes
+import time
+from pathlib import Path
+from typing import Any, TYPE_CHECKING
+
+import requests
+
+from .._models import UploadedFile
+from .._utils import _UNSET, _is_given
+
+if TYPE_CHECKING:
+    from .._client import CodexClient
+
+FILE_URI_PREFIX = "sediment://"
+FILE_UPLOAD_LIMIT_BYTES = 512 * 1024 * 1024
+FILE_USE_CASE = "codex"
+
+
+class Files:
+    """File uploads for Codex Apps/MCP file parameters."""
+
+    def __init__(self, client: CodexClient) -> None:
+        self._client = client
+
+    def upload(
+        self,
+        path: str | Path,
+        *,
+        timeout: Any = _UNSET,
+        finalize_timeout: float = 30,
+        finalize_retry_delay: float = 0.25,
+    ) -> UploadedFile:
+        file_path = Path(path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"path `{file_path}` does not exist")
+        if not file_path.is_file():
+            raise ValueError(f"path `{file_path}` is not a file")
+
+        size = file_path.stat().st_size
+        if size > FILE_UPLOAD_LIMIT_BYTES:
+            raise ValueError(
+                f"file `{file_path}` is too large: {size} bytes exceeds "
+                f"the limit of {FILE_UPLOAD_LIMIT_BYTES} bytes"
+            )
+
+        file_name = file_path.name or "file"
+        create_payload = self._client._post_chatgpt(
+            "/files",
+            body={"file_name": file_name, "file_size": size, "use_case": FILE_USE_CASE},
+            timeout=timeout,
+        )
+        file_id = create_payload["file_id"]
+        upload_url = create_payload["upload_url"]
+
+        with file_path.open("rb") as handle:
+            upload_response = requests.put(
+                upload_url,
+                data=handle,
+                headers={
+                    "x-ms-blob-type": "BlockBlob",
+                    "Content-Length": str(size),
+                },
+                timeout=self._request_timeout(timeout),
+            )
+        upload_response.raise_for_status()
+
+        finalize_payload = self._finalize_upload(
+            file_id,
+            timeout=timeout,
+            finalize_timeout=finalize_timeout,
+            finalize_retry_delay=finalize_retry_delay,
+        )
+        return UploadedFile(
+            file_id=file_id,
+            uri=f"{FILE_URI_PREFIX}{file_id}",
+            download_url=finalize_payload["download_url"],
+            file_name=finalize_payload.get("file_name") or file_name,
+            file_size_bytes=size,
+            mime_type=finalize_payload.get("mime_type") or mimetypes.guess_type(file_name)[0],
+            path=str(file_path),
+        )
+
+    def _finalize_upload(
+        self,
+        file_id: str,
+        *,
+        timeout: Any,
+        finalize_timeout: float,
+        finalize_retry_delay: float,
+    ) -> dict[str, Any]:
+        deadline = time.monotonic() + finalize_timeout
+        while True:
+            payload = self._client._post_chatgpt(
+                f"/files/{file_id}/uploaded",
+                body={},
+                timeout=timeout,
+            )
+            status = payload.get("status")
+            if status == "success":
+                if not payload.get("download_url"):
+                    raise RuntimeError(f"OpenAI file upload for `{file_id}` failed: missing download_url")
+                return payload
+            if status == "retry" and time.monotonic() < deadline:
+                time.sleep(finalize_retry_delay)
+                continue
+            if status == "retry":
+                raise TimeoutError(f"OpenAI file upload for `{file_id}` is not ready yet")
+            message = payload.get("error_message") or "upload finalization returned an error"
+            raise RuntimeError(f"OpenAI file upload for `{file_id}` failed: {message}")
+
+    def _request_timeout(self, timeout: Any) -> Any:
+        return self._client._timeout if not _is_given(timeout) else timeout

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/resources/models.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import time
 from typing import Any, TYPE_CHECKING
 
 from .._models import Model, SyncPage
@@ -10,25 +11,38 @@ from .._utils import _UNSET
 if TYPE_CHECKING:
     from .._client import CodexClient
 
-CLIENT_VERSION = "0.3.0"
+# This is the upstream Codex CLI protocol/client version expected by the
+# ChatGPT backend, not the PyPI package version.
+CLIENT_VERSION = "0.130.0"
+_CACHE_TTL = 300
 
 
 class Models:
     def __init__(self, client: CodexClient) -> None:
         self._client = client
+        self._cache: SyncPage | None = None
+        self._cache_fetched_at = 0.0
 
     def list(
         self,
         *,
+        force_refresh: bool = False,
         extra_headers: Any = None,
         extra_query: Any = None,
         extra_body: Any = None,
         timeout: Any = _UNSET,
     ) -> SyncPage:
+        if not force_refresh and self._cache is not None:
+            if time.time() - self._cache_fetched_at <= _CACHE_TTL:
+                return self._cache
+
         data = self._client._get("/models", params={"client_version": CLIENT_VERSION})
         models = [_model_from_backend(item) for item in data.get("models", [])]
-        models.sort(key=lambda model: getattr(model, "priority", 0), reverse=True)
-        return SyncPage(data=models)
+        models.sort(key=lambda model: getattr(model, "priority", 0))
+        page = SyncPage(data=models)
+        self._cache = page
+        self._cache_fetched_at = time.time()
+        return page
 
     def retrieve(
         self,

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/resources/realtime.py

@@ -1,8 +1,6 @@
 """Realtime resources."""
 
 from __future__ import annotations
-
-import json
 from typing import Any, Optional, TYPE_CHECKING
 
 from .._models import RealtimeCallResponse
@@ -51,17 +49,13 @@ class RealtimeCalls:
             )
             return RealtimeCallResponse(response)
 
-        files = [
-            ("sdp", (None, sdp.encode("utf-8"), "application/sdp")),
-            (
-                "session",
-                (None, json.dumps(_jsonable(session)).encode("utf-8"), "application/json"),
-            ),
-        ]
         response = self._client._post_raw(
             "/realtime/calls",
-            files=files,
-            data=extra_body,
+            body={
+                "sdp": sdp,
+                "session": _jsonable(session),
+                **(_jsonable(extra_body) if extra_body else {}),
+            },
             headers={"Accept": "application/sdp", **(extra_headers or {})},
             params=extra_query,
             timeout=timeout,

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/codex_backend_sdk/resources/responses.py

@@ -115,14 +115,31 @@ class Responses:
         input: list[dict[str, Any]],
         model: Any = _UNSET,
         instructions: Any = _UNSET,
+        tools: Any = _UNSET,
+        parallel_tool_calls: Any = _UNSET,
+        reasoning: Any = _UNSET,
+        service_tier: Any = _UNSET,
+        prompt_cache_key: Any = _UNSET,
+        text: Any = _UNSET,
     ) -> CompactedResponse:
+        normalized_tools = _normalize_tools(tools)
         payload = {
             "model": _default(model, self._client._defaults["model"]),
             "instructions": _default(instructions, self._client._defaults["instructions"]) or "",
             "input": [_normalize_input_item(item) for item in input],
-            "tools": [],
-            "parallel_tool_calls": False,
+            "tools": normalized_tools,
+            "parallel_tool_calls": (
+                bool(_default(parallel_tool_calls, False)) if normalized_tools else False
+            ),
         }
+        if _is_given(reasoning) and reasoning is not None:
+            payload["reasoning"] = _normalize_reasoning(reasoning)
+        if _is_given(service_tier) and service_tier is not None:
+            payload["service_tier"] = service_tier
+        if _is_given(prompt_cache_key) and prompt_cache_key is not None:
+            payload["prompt_cache_key"] = prompt_cache_key
+        if _is_given(text) and text is not None:
+            payload["text"] = _normalize_text(text)
         data = self._client._post("/responses/compact", body=payload).json()
         return CompactedResponse(id=data.get("id", ""), output=data.get("output", []))
 

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/docs/backend-api.md

@@ -43,7 +43,7 @@ List models available to this account.
 **SDK method**: `client.models.list()` / `client.models.retrieve(model)`
 
 **Query params**
-- `client_version` — SDK/CLI version string (e.g. `"0.3.0"`).
+- `client_version` — Codex CLI protocol/client version string (e.g. `"0.130.0"`).
 
 **Response** — JSON `{ "models": [ ModelObject, … ] }`
 
@@ -193,7 +193,14 @@ Compact a long conversation into an encrypted summary the model can still read.
 ```json
 {
   "model": "gpt-5.4",
-  "input": [ /* full conversation history */ ]
+  "input": [ /* full conversation history */ ],
+  "instructions": "Compact the conversation.",
+  "tools": [],
+  "parallel_tool_calls": false,
+  "reasoning": { "effort": "medium" },
+  "service_tier": "priority",
+  "prompt_cache_key": "cache-key",
+  "text": { "verbosity": "low" }
 }
 ```
 
@@ -219,7 +226,27 @@ Compact a long conversation into an encrypted summary the model can still read.
 
 Summarize traces into persistent memories.
 
-**Status**: Returns `403 Forbidden` on Plus plan. Requires Pro or Enterprise.
+**SDK method**: `client.codex.memories.trace_summarize(...)`
+
+**Status**: Supported as a raw helper. May return `403 Forbidden` depending on
+plan/account capabilities.
+
+**Request body**:
+```json
+{
+  "model": "gpt-5.4",
+  "traces": [
+    {
+      "id": "trace_1",
+      "metadata": { "source_path": "memory.jsonl" },
+      "items": [ /* normalized trace items */ ]
+    }
+  ],
+  "reasoning": { "effort": "low" }
+}
+```
+
+**Response** — raw JSON, typically `{ "output": [...] }`.
 
 ---
 
@@ -342,6 +369,8 @@ Known `rate_limit_reached_type.type` values: `rate_limit_reached`, `workspace_ow
 
 Fetch managed requirements/config for this account (plan-gated settings).
 
+**SDK method**: `client.codex.config.requirements()`
+
 **Response** — JSON config blob; schema defined in `codex-rs/cloud-requirements`.
 
 ---
@@ -404,6 +433,27 @@ Remote control / agent-as-a-service websocket. Enrollment via:
 
 ---
 
+## ChatGPT File Uploads
+
+### `POST /backend-api/files`
+
+Create file upload metadata for Codex Apps/MCP file parameters.
+
+**SDK method**: `client.files.upload(path)`
+
+The official flow is:
+
+1. `POST /backend-api/files` with `file_name`, `file_size`, and
+   `use_case: "codex"`.
+2. `PUT` the file bytes to the returned signed `upload_url`.
+3. `POST /backend-api/files/{file_id}/uploaded` until the backend returns
+   `status: "success"`.
+
+The SDK returns an `UploadedFile` object with `file_id`, canonical
+`sediment://...` URI, download URL, file name, size, MIME type, and local path.
+
+---
+
 ## ChatGPT Account Data
 
 These endpoints are under `https://chatgpt.com/backend-api`, not

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/pyproject.toml

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

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/tests/test_codex_resources.py

@@ -6,11 +6,14 @@ class FakeCodexClient(OpenAI):
         super().__init__(model="gpt-test")
         self.wham_gets = []
         self.chatgpt_gets = []
+        self.posts = []
 
     def _get_wham(self, path, *, params=None):
         self.wham_gets.append((path, params))
         if path == "/wham/usage":
             return {"rate_limit": {"allowed": True}}
+        if path == "/wham/config/requirements":
+            return {"requirements": [{"name": "network"}]}
         if path == "/wham/tasks/list":
             return {"items": [{"id": "task_1", "title": "Task"}], "cursor": None}
         if path == "/wham/tasks/task_1":
@@ -35,6 +38,20 @@ class FakeCodexClient(OpenAI):
             return {"object": "user_system_message_detail", "enabled": True}
         raise AssertionError(f"Unexpected path: {path}")
 
+    def _post(self, path, *, body, stream=False):
+        self.posts.append((path, body, stream))
+        if path == "/memories/trace_summarize":
+            return FakeJSONResponse({"output": [{"memory_summary": "summary"}]})
+        raise AssertionError(f"Unexpected Codex post path: {path}")
+
+
+class FakeJSONResponse:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def json(self):
+        return self._payload
+
 
 def test_codex_usage_still_calls_wham_usage():
     client = FakeCodexClient()
@@ -54,6 +71,41 @@ def test_codex_memories_list_returns_raw_chatgpt_payload():
     assert client.chatgpt_gets == ["/memories"]
 
 
+def test_codex_memories_trace_summarize_posts_codex_payload():
+    client = FakeCodexClient()
+
+    response = client.codex.memories.trace_summarize(
+        model="gpt-test",
+        traces=[
+            {
+                "id": "trace_1",
+                "metadata": {"source_path": "/tmp/memory.jsonl"},
+                "items": [{"type": "message", "content": "remember me"}],
+            }
+        ],
+        reasoning={"effort": "low"},
+    )
+
+    assert response == {"output": [{"memory_summary": "summary"}]}
+    assert client.posts == [
+        (
+            "/memories/trace_summarize",
+            {
+                "model": "gpt-test",
+                "traces": [
+                    {
+                        "id": "trace_1",
+                        "metadata": {"source_path": "/tmp/memory.jsonl"},
+                        "items": [{"type": "message", "content": "remember me"}],
+                    }
+                ],
+                "reasoning": {"effort": "low"},
+            },
+            False,
+        )
+    ]
+
+
 def test_codex_user_system_messages_retrieve_returns_raw_chatgpt_payload():
     client = FakeCodexClient()
 
@@ -110,3 +162,12 @@ def test_codex_environments_list_returns_raw_payload():
 
     assert environments == [{"id": "env_1", "label": "default"}]
     assert client.wham_gets == [("/wham/environments", None)]
+
+
+def test_codex_config_requirements_returns_raw_payload():
+    client = FakeCodexClient()
+
+    requirements = client.codex.config.requirements()
+
+    assert requirements == {"requirements": [{"name": "network"}]}
+    assert client.wham_gets == [("/wham/config/requirements", None)]

codex_backend_sdk-0.3.1/tests/test_files_resource.py

@@ -0,0 +1,114 @@
+from pathlib import Path
+
+from codex_backend_sdk import OpenAI, UploadedFile
+from codex_backend_sdk.storage import TokenStore
+
+
+class FakePutResponse:
+    def __init__(self):
+        self.raised = False
+
+    def raise_for_status(self):
+        self.raised = True
+
+
+class FakeFilesClient(OpenAI):
+    def __init__(self):
+        super().__init__(model="gpt-test")
+        self.chatgpt_posts = []
+        self._set_store(TokenStore(
+            access_token="chatgpt-token",
+            refresh_token="refresh-token",
+            id_token_raw="id-token",
+            account_id="account-id",
+        ))
+
+    def _post_chatgpt(self, path, *, body, timeout=None):
+        self.chatgpt_posts.append((path, body, timeout))
+        if path == "/files":
+            return {"file_id": "file_123", "upload_url": "https://upload.example/file_123"}
+        if path == "/files/file_123/uploaded":
+            return {
+                "status": "success",
+                "download_url": "https://download.example/file_123",
+                "file_name": "report.txt",
+                "mime_type": "text/plain",
+            }
+        raise AssertionError(f"Unexpected ChatGPT post path: {path}")
+
+
+def test_files_upload_uses_chatgpt_file_flow(tmp_path, monkeypatch):
+    client = FakeFilesClient()
+    file_path = tmp_path / "report.txt"
+    file_path.write_text("hello")
+    put_calls = []
+
+    def fake_put(url, *, data, headers, timeout):
+        put_calls.append((url, data.read(), headers, timeout))
+        return FakePutResponse()
+
+    monkeypatch.setattr("codex_backend_sdk.resources.files.requests.put", fake_put)
+
+    uploaded = client.files.upload(file_path)
+
+    assert isinstance(uploaded, UploadedFile)
+    assert uploaded.file_id == "file_123"
+    assert uploaded.uri == "sediment://file_123"
+    assert uploaded.download_url == "https://download.example/file_123"
+    assert uploaded.file_name == "report.txt"
+    assert uploaded.file_size_bytes == 5
+    assert uploaded.mime_type == "text/plain"
+    assert uploaded.path == str(file_path)
+    assert client.chatgpt_posts[0][:2] == (
+        "/files",
+        {"file_name": "report.txt", "file_size": 5, "use_case": "codex"},
+    )
+    assert client.chatgpt_posts[1][:2] == ("/files/file_123/uploaded", {})
+    assert put_calls == [
+        (
+            "https://upload.example/file_123",
+            b"hello",
+            {"x-ms-blob-type": "BlockBlob", "Content-Length": "5"},
+            120,
+        )
+    ]
+
+
+def test_files_upload_rejects_missing_path():
+    client = FakeFilesClient()
+
+    try:
+        client.files.upload(Path("/does/not/exist"))
+    except FileNotFoundError as exc:
+        assert "does not exist" in str(exc)
+    else:
+        raise AssertionError("missing path should fail before network calls")
+
+
+def test_files_upload_retries_finalize_payload(tmp_path, monkeypatch):
+    class RetryFilesClient(FakeFilesClient):
+        def __init__(self):
+            super().__init__()
+            self.finalize_calls = 0
+
+        def _post_chatgpt(self, path, *, body, timeout=None):
+            if path == "/files/file_123/uploaded":
+                self.finalize_calls += 1
+                if self.finalize_calls == 1:
+                    return {"status": "retry"}
+            return super()._post_chatgpt(path, body=body, timeout=timeout)
+
+    client = RetryFilesClient()
+    file_path = tmp_path / "report.txt"
+    file_path.write_text("hello")
+
+    monkeypatch.setattr(
+        "codex_backend_sdk.resources.files.requests.put",
+        lambda *args, **kwargs: FakePutResponse(),
+    )
+    monkeypatch.setattr("codex_backend_sdk.resources.files.time.sleep", lambda delay: None)
+
+    uploaded = client.files.upload(file_path, finalize_retry_delay=0)
+
+    assert uploaded.file_id == "file_123"
+    assert client.finalize_calls == 2

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/tests/test_realtime_resource.py

@@ -51,7 +51,7 @@ def test_realtime_calls_create_posts_plain_sdp_like_official_sdk():
     assert kwargs["headers"]["Content-Type"] == "application/sdp"
 
 
-def test_realtime_calls_create_posts_session_as_multipart():
+def test_realtime_calls_create_posts_session_as_backend_json():
     client = FakeRealtimeClient()
 
     client.realtime.calls.create(
@@ -61,9 +61,11 @@ def test_realtime_calls_create_posts_session_as_multipart():
 
     path, kwargs = client.raw_posts[0]
     assert path == "/realtime/calls"
-    assert kwargs["files"][0][0] == "sdp"
-    assert kwargs["files"][1][0] == "session"
-    assert b"gpt-realtime-1.5" in kwargs["files"][1][1][1]
+    assert kwargs["body"] == {
+        "sdp": "offer-sdp",
+        "session": {"type": "realtime", "model": "gpt-realtime-1.5"},
+    }
+    assert kwargs["headers"]["Accept"] == "application/sdp"
 
 
 def test_realtime_websocket_helpers_match_codex_agent_plugin_contract():

{codex_backend_sdk-0.3.0 → codex_backend_sdk-0.3.1}/tests/test_responses_resource.py

@@ -14,6 +14,14 @@ class FakeSSE:
         yield b""
 
 
+class FakeJSONResponse:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def json(self):
+        return self._payload
+
+
 class FakeClient(OpenAI):
     def __init__(self):
         super().__init__(model="gpt-test")
@@ -22,6 +30,11 @@ class FakeClient(OpenAI):
 
     def _post(self, path, *, body, stream=False):
         self.posts.append((path, body, stream))
+        if path == "/responses/compact":
+            return FakeJSONResponse({
+                "id": "resp_123",
+                "output": [{"type": "message", "content": []}],
+            })
         return FakeSSE([
             'data: {"type":"response.content_part.delta","delta":{"text":"hel"}}',
             "",
@@ -39,12 +52,20 @@ class FakeClient(OpenAI):
         return {
             "models": [
                 {
-                    "slug": "gpt-test",
-                    "display_name": "GPT Test",
+                    "slug": "gpt-lower-priority",
+                    "display_name": "GPT Lower Priority",
                     "description": "Test model",
                     "context_window": 123,
                     "supported_in_api": True,
                     "priority": 7,
+                },
+                {
+                    "slug": "gpt-test",
+                    "display_name": "GPT Test",
+                    "description": "Test model",
+                    "context_window": 456,
+                    "supported_in_api": True,
+                    "priority": 1,
                 }
             ]
         }
@@ -123,11 +144,58 @@ def test_models_resource_returns_iterable_page():
     page = client.models.list()
     model = page[0]
 
-    assert len(page) == 1
-    assert list(page) == [model]
+    assert len(page) == 2
     assert model.id == "gpt-test"
-    assert model.context_window == 123
+    assert model.context_window == 456
     assert client.models.retrieve("gpt-test").id == "gpt-test"
+    assert len(client.gets) == 1
+
+
+def test_models_resource_can_force_refresh_cached_page():
+    client = FakeClient()
+
+    assert client.models.list() is client.models.list()
+    client.models.list(force_refresh=True)
+
+    assert len(client.gets) == 2
+
+
+def test_responses_compact_sends_shared_request_fields():
+    client = FakeClient()
+
+    compacted = client.responses.compact(
+        model="gpt-test",
+        input=[{"role": "user", "content": "Long context"}],
+        instructions="Compact this.",
+        tools=[{"type": "web_search"}],
+        parallel_tool_calls=True,
+        reasoning={"effort": "medium"},
+        service_tier="priority",
+        prompt_cache_key="cache-key",
+        text={"verbosity": "low"},
+    )
+
+    assert compacted.id == "resp_123"
+    path, payload, stream = client.posts[0]
+    assert path == "/responses/compact"
+    assert stream is False
+    assert payload == {
+        "model": "gpt-test",
+        "instructions": "Compact this.",
+        "input": [
+            {
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "Long context"}],
+            }
+        ],
+        "tools": [{"type": "web_search_preview"}],
+        "parallel_tool_calls": True,
+        "reasoning": {"effort": "medium"},
+        "service_tier": "priority",
+        "prompt_cache_key": "cache-key",
+        "text": {"verbosity": "low"},
+    }
 
 
 def test_responses_create_rejects_official_params_not_exposed_by_codex_backend():

codex_backend_sdk-0.3.0/tools/probe_v1_endpoints.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-"""Probe OpenAI/Codex endpoints available to the current ChatGPT auth store.
-
-The default mode is intentionally read-only: it sends GET/OPTIONS requests to
-candidate endpoints and records status codes, content types, request IDs, and a
-small body preview. It does not create resources.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import time
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any
-from urllib.parse import urljoin
-
-import requests
-
-from codex_backend_sdk.storage import TokenStore, load_tokens
-
-
-OPENAI_BASE_URL = "https://api.openai.com/v1"
-CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"
-WHAM_BASE_URL = "https://chatgpt.com/backend-api"
-ORIGINATOR = "codex_cli_rs"
-
-
-@dataclass(frozen=True)
-class Candidate:
-    name: str
-    base: str
-    method: str
-    path: str
-    auth: str
-    params: dict[str, Any] | None = None
-    headers: dict[str, str] | None = None
-    body: dict[str, Any] | None = None
-    mutating: bool = False
-    note: str = ""
-
-
-@dataclass
-class ProbeResult:
-    name: str
-    base: str
-    method: str
-    path: str
-    url: str
-    auth: str
-    status_code: int | None
-    category: str
-    elapsed_ms: int
-    content_type: str | None = None
-    request_id: str | None = None
-    allow: str | None = None
-    body_preview: Any = None
-    error: str | None = None
-    note: str = ""
-
-
-def openai_candidates() -> list[Candidate]:
-    base_headers = {"OpenAI-Beta": "assistants=v2"}
-    return [
-        Candidate("models.list", OPENAI_BASE_URL, "GET", "/models", "openai"),
-        Candidate("files.list", OPENAI_BASE_URL, "GET", "/files", "openai", {"limit": 1}),
-        Candidate("vector_stores.list", OPENAI_BASE_URL, "GET", "/vector_stores", "openai", {"limit": 1}, base_headers),
-        Candidate("assistants.list", OPENAI_BASE_URL, "GET", "/assistants", "openai", {"limit": 1}, base_headers),
-        Candidate("threads.probe", OPENAI_BASE_URL, "OPTIONS", "/threads", "openai", headers=base_headers),
-        Candidate("responses.probe", OPENAI_BASE_URL, "OPTIONS", "/responses", "openai"),
-        Candidate("responses.compact.probe", OPENAI_BASE_URL, "OPTIONS", "/responses/compact", "openai"),
-        Candidate("realtime.calls.probe", OPENAI_BASE_URL, "OPTIONS", "/realtime/calls", "openai", headers={"OpenAI-Beta": "realtime=v1"}),
-        Candidate("batches.list", OPENAI_BASE_URL, "GET", "/batches", "openai", {"limit": 1}),
-        Candidate("uploads.probe", OPENAI_BASE_URL, "OPTIONS", "/uploads", "openai"),
-        Candidate("containers.list", OPENAI_BASE_URL, "GET", "/containers", "openai", {"limit": 1}),
-        Candidate("evals.list", OPENAI_BASE_URL, "GET", "/evals", "openai", {"limit": 1}),
-        Candidate("fine_tuning.jobs.list", OPENAI_BASE_URL, "GET", "/fine_tuning/jobs", "openai", {"limit": 1}),
-        Candidate("organization.costs", OPENAI_BASE_URL, "GET", "/organization/costs", "openai", {"limit": 1}),
-        Candidate("organization.usage.completions", OPENAI_BASE_URL, "GET", "/organization/usage/completions", "openai", {"limit": 1}),
-        Candidate("organization.usage.responses", OPENAI_BASE_URL, "GET", "/organization/usage/responses", "openai", {"limit": 1}),
-        Candidate("organization.usage.vector_stores", OPENAI_BASE_URL, "GET", "/organization/usage/vector_stores", "openai", {"limit": 1}),
-        Candidate("moderations.probe", OPENAI_BASE_URL, "OPTIONS", "/moderations", "openai"),
-        Candidate("images.probe", OPENAI_BASE_URL, "OPTIONS", "/images/generations", "openai"),
-        Candidate("audio.speech.probe", OPENAI_BASE_URL, "OPTIONS", "/audio/speech", "openai"),
-        Candidate("audio.transcriptions.probe", OPENAI_BASE_URL, "OPTIONS", "/audio/transcriptions", "openai"),
-        Candidate("chat.completions.probe", OPENAI_BASE_URL, "OPTIONS", "/chat/completions", "openai"),
-        Candidate("embeddings.probe", OPENAI_BASE_URL, "OPTIONS", "/embeddings", "openai"),
-    ]
-
-
-def chatgpt_candidates() -> list[Candidate]:
-    return [
-        Candidate("codex.models", CODEX_BASE_URL, "GET", "/models", "chatgpt", {"client_version": "0.3.0"}),
-        Candidate("codex.responses.probe", CODEX_BASE_URL, "OPTIONS", "/responses", "chatgpt"),
-        Candidate("codex.responses.compact.probe", CODEX_BASE_URL, "OPTIONS", "/responses/compact", "chatgpt"),
-        Candidate("codex.realtime.calls.probe", CODEX_BASE_URL, "OPTIONS", "/realtime/calls", "chatgpt"),
-        Candidate("codex.memories.trace_summarize.probe", CODEX_BASE_URL, "OPTIONS", "/memories/trace_summarize", "chatgpt"),
-        Candidate("wham.usage", WHAM_BASE_URL, "GET", "/wham/usage", "chatgpt"),
-        Candidate("wham.config.requirements", WHAM_BASE_URL, "GET", "/wham/config/requirements", "chatgpt"),
-        Candidate("wham.tasks.list", WHAM_BASE_URL, "GET", "/wham/tasks/list", "chatgpt", {"limit": 1}),
-        Candidate("wham.remote.control.enroll.probe", WHAM_BASE_URL, "OPTIONS", "/wham/remote/control/server/enroll", "chatgpt"),
-    ]
-
-
-def build_headers(store: TokenStore, auth: str, extra: dict[str, str] | None) -> dict[str, str]:
-    if auth == "openai":
-        if not store.openai_api_key:
-            raise RuntimeError("No openai_api_key in auth store. Run authenticate(request_api_key=True).")
-        headers = {"Authorization": f"Bearer {store.openai_api_key}"}
-    elif auth == "chatgpt":
-        headers = {
-            "Authorization": f"Bearer {store.access_token}",
-            "originator": ORIGINATOR,
-            "OpenAI-Beta": "responses=experimental",
-        }
-        if store.account_id:
-            headers["ChatGPT-Account-ID"] = store.account_id
-    else:
-        raise ValueError(f"Unknown auth mode: {auth}")
-
-    headers.update(extra or {})
-    return headers
-
-
-def categorize(status_code: int | None, error: str | None = None) -> str:
-    if error is not None:
-        return "error"
-    if status_code is None:
-        return "error"
-    if 200 <= status_code < 300:
-        return "available"
-    if status_code == 401:
-        return "unauthenticated"
-    if status_code == 403:
-        return "forbidden_or_plan_gated"
-    if status_code == 404:
-        return "not_found_or_hidden"
-    if status_code == 405:
-        return "exists_method_not_allowed"
-    if status_code == 429:
-        return "rate_limited"
-    if 400 <= status_code < 500:
-        return "client_rejected"
-    if 500 <= status_code < 600:
-        return "server_error"
-    return "other"
-
-
-def preview_body(response: requests.Response) -> Any:
-    text = response.text[:1000]
-    content_type = response.headers.get("content-type", "")
-    if "json" not in content_type:
-        return text
-    try:
-        data = response.json()
-    except ValueError:
-        return text
-    if isinstance(data, dict):
-        return redact(data)
-    return data
-
-
-def redact(value: Any) -> Any:
-    if isinstance(value, dict):
-        redacted: dict[str, Any] = {}
-        for key, item in value.items():
-            lowered = key.lower()
-            if any(secret in lowered for secret in ("token", "secret", "key", "email", "account_id", "user_id")):
-                redacted[key] = "[redacted]"
-            else:
-                redacted[key] = redact(item)
-        return redacted
-    if isinstance(value, list):
-        return [redact(item) for item in value]
-    return value
-
-
-def probe(candidate: Candidate, store: TokenStore, timeout: float) -> ProbeResult:
-    url = urljoin(candidate.base.rstrip("/") + "/", candidate.path.lstrip("/"))
-    start = time.monotonic()
-    try:
-        response = requests.request(
-            candidate.method,
-            url,
-            params=candidate.params,
-            json=candidate.body,
-            headers=build_headers(store, candidate.auth, candidate.headers),
-            timeout=timeout,
-        )
-        elapsed_ms = int((time.monotonic() - start) * 1000)
-        return ProbeResult(
-            name=candidate.name,
-            base=candidate.base,
-            method=candidate.method,
-            path=candidate.path,
-            url=response.url,
-            auth=candidate.auth,
-            status_code=response.status_code,
-            category=categorize(response.status_code),
-            elapsed_ms=elapsed_ms,
-            content_type=response.headers.get("content-type"),
-            request_id=response.headers.get("x-request-id") or response.headers.get("openai-processing-ms"),
-            allow=response.headers.get("allow"),
-            body_preview=preview_body(response),
-            note=candidate.note,
-        )
-    except Exception as exc:
-        elapsed_ms = int((time.monotonic() - start) * 1000)
-        return ProbeResult(
-            name=candidate.name,
-            base=candidate.base,
-            method=candidate.method,
-            path=candidate.path,
-            url=url,
-            auth=candidate.auth,
-            status_code=None,
-            category=categorize(None, str(exc)),
-            elapsed_ms=elapsed_ms,
-            error=f"{type(exc).__name__}: {exc}",
-            note=candidate.note,
-        )
-
-
-def select_candidates(scope: str, include_mutating: bool) -> list[Candidate]:
-    candidates: list[Candidate] = []
-    if scope in {"all", "openai"}:
-        candidates.extend(openai_candidates())
-    if scope in {"all", "chatgpt"}:
-        candidates.extend(chatgpt_candidates())
-    if not include_mutating:
-        candidates = [candidate for candidate in candidates if not candidate.mutating]
-    return candidates
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--scope", choices=["all", "openai", "chatgpt"], default="all")
-    parser.add_argument("--output", type=Path, default=Path("endpoint-probe-results.json"))
-    parser.add_argument("--timeout", type=float, default=20)
-    parser.add_argument("--sleep", type=float, default=0.25, help="Delay between probes in seconds.")
-    parser.add_argument("--include-mutating", action="store_true", help="Include candidates marked mutating.")
-    args = parser.parse_args()
-
-    store = load_tokens()
-    if store is None:
-        raise SystemExit("No Codex auth store found. Run `python -c 'from codex_backend_sdk import OpenAI; OpenAI().authenticate()'` first.")
-
-    results: list[ProbeResult] = []
-    for candidate in select_candidates(args.scope, args.include_mutating):
-        result = probe(candidate, store, args.timeout)
-        results.append(result)
-        print(f"{result.category:25} {result.status_code or '-':>3} {candidate.method:7} {candidate.auth:7} {candidate.path} ({candidate.name})")
-        if args.sleep:
-            time.sleep(args.sleep)
-
-    payload = {
-        "generated_at": int(time.time()),
-        "scope": args.scope,
-        "read_only_default": not args.include_mutating,
-        "results": [asdict(result) for result in results],
-    }
-    args.output.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
-    print(f"\nWrote {args.output}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())