codex-backend-sdk 0.3.3__tar.gz → 0.3.5__tar.gz

codex_backend_sdk-0.3.5/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.3.5] - 2026-05-18
+
+### Fixed
+- Preserved `usage` on `client.responses.compact(...)` results so `CompactedResponse` exposes backend token accounting.
+
+### Tests
+- Added coverage to verify compact responses retain `input_tokens`, `output_tokens`, and `total_tokens`.
+
+## [0.3.4] - 2026-05-15
+
+### Added
+- Added `authenticate(interactive=False)` to allow non-interactive credential checks without triggering the browser OAuth flow.
+- Added `client.authenticated` for simple auth-state introspection.
+- Added `client.account_info()` to expose safe non-secret account metadata (`authenticated`, `account_id`, `email`, `plan_type`).
+
+### Documentation
+- Documented the non-interactive authentication helpers in `README.md`.

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-backend-sdk
-Version: 0.3.3
+Version: 0.3.5
 Summary: Unofficial Python SDK for the ChatGPT Codex backend API
 License: MIT
 License-File: LICENSE
@@ -355,6 +355,14 @@ headers = client.realtime_websocket_headers(session_id="voice-session")
 `openai_api_key`. The default `authenticate(request_api_key=True)` flow stores
 that key when available.
 
+For non-interactive checks, you can avoid triggering a browser login flow:
+
+```python
+client = OpenAI().authenticate(interactive=False)
+print(client.authenticated)
+print(client.account_info())
+```
+
 ### Embeddings
 
 `client.embeddings.create(...)` mirrors the official OpenAI embeddings resource

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/README.md

@@ -329,6 +329,14 @@ headers = client.realtime_websocket_headers(session_id="voice-session")
 `openai_api_key`. The default `authenticate(request_api_key=True)` flow stores
 that key when available.
 
+For non-interactive checks, you can avoid triggering a browser login flow:
+
+```python
+client = OpenAI().authenticate(interactive=False)
+print(client.authenticated)
+print(client.account_info())
+```
+
 ### Embeddings
 
 `client.embeddings.create(...)` mirrors the official OpenAI embeddings resource

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/codex_backend_sdk/__init__.py

@@ -17,7 +17,7 @@ Quickstart:
     print(response.output_text)
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"
 
 from .oauth import run_oauth_flow, refresh_access_token, obtain_api_key
 from .storage import load_tokens, save_tokens, TokenStore

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/codex_backend_sdk/_client.py

@@ -62,7 +62,12 @@ class CodexClient:
         self.files = Files(self)
         self.codex = CodexResources(self)
 
-    def authenticate(self, *, request_api_key: bool = True) -> "CodexClient":
+    def authenticate(
+        self,
+        *,
+        request_api_key: bool = True,
+        interactive: bool = True,
+    ) -> "CodexClient":
         from .oauth import refresh_access_token, run_oauth_flow
 
         def refresh(store: TokenStore) -> Optional[TokenStore]:
@@ -87,9 +92,28 @@ class CodexClient:
                 self._set_store(store)
                 return self
 
+        if not interactive:
+            raise RuntimeError("No usable stored Codex credentials; interactive login required.")
+
         self._set_store(run_oauth_flow(request_api_key=request_api_key))
         return self
 
+    @property
+    def authenticated(self) -> bool:
+        """Whether this client currently has OAuth credentials loaded."""
+        return bool(self._store and self._store.account_id)
+
+    def account_info(self) -> dict[str, Any]:
+        """Return safe non-secret account metadata decoded from stored tokens."""
+        store = self._store
+        authenticated = bool(store and store.account_id)
+        return {
+            "authenticated": authenticated,
+            "account_id": store.account_id if store else None,
+            "email": store.email if store else None,
+            "plan_type": store.plan_type if store else None,
+        }
+
     def _set_store(self, store: TokenStore) -> None:
         self._store = store
         self._session.headers.update(self._auth_headers())

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/codex_backend_sdk/_models.py

@@ -258,6 +258,7 @@ class CompactedResponse(CodexBaseModel):
     id: str
     object: str = "response.compacted"
     output: list[dict[str, Any]] = Field(default_factory=list)
+    usage: Optional[ResponseUsage] = Field(default_factory=ResponseUsage)
 
 
 class BinaryResponseContent:

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/codex_backend_sdk/resources/_responses_payloads.py

@@ -175,13 +175,7 @@ def normalize_input_item(item: Any) -> dict[str, Any]:
 def normalize_tools(tools: Any) -> list[dict[str, Any]]:
     if not _is_given(tools) or tools is None:
         return []
-    normalized = []
-    for tool in tools:
-        item = _as_dict(tool)
-        if item.get("type") == "web_search":
-            item["type"] = "web_search_preview"
-        normalized.append(item)
-    return normalized
+    return [_as_dict(tool) for tool in tools]
 
 
 def normalize_reasoning(reasoning: Any) -> dict[str, Any]:

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/codex_backend_sdk/resources/responses.py

@@ -10,6 +10,7 @@ from .._streaming import stream_response_events
 from .._utils import _UNSET, _default, _is_given, _reject_backend_unsupported
 from ._responses_payloads import (
     ResponsesCreateRequest,
+    _usage_from_backend,
     collect_response,
     merge_text_format,
     normalize_input_item,
@@ -221,4 +222,9 @@ class Responses:
         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", []))
+        return CompactedResponse(
+            id=data.get("id", ""),
+            object=data.get("object", "response.compacted"),
+            output=data.get("output", []),
+            usage=_usage_from_backend(data.get("usage")),
+        )

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/pyproject.toml

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

codex_backend_sdk-0.3.5/tests/test_account_info.py

@@ -0,0 +1,68 @@
+from codex_backend_sdk import CodexClient, TokenStore
+
+
+
+def _store() -> TokenStore:
+    return TokenStore(
+        access_token="access-secret",
+        refresh_token="refresh-secret",
+        id_token_raw="id-secret",
+        account_id="acct_123",
+        openai_api_key="api-secret",
+        email="user@example.com",
+        plan_type="pro",
+    )
+
+
+
+def test_account_info_exposes_safe_metadata_only():
+    client = CodexClient(store=_store())
+
+    info = client.account_info()
+
+    assert client.authenticated is True
+    assert info == {
+        "authenticated": True,
+        "account_id": "acct_123",
+        "email": "user@example.com",
+        "plan_type": "pro",
+    }
+    assert "access-secret" not in repr(info)
+    assert "refresh-secret" not in repr(info)
+    assert "api-secret" not in repr(info)
+
+
+
+def test_account_info_when_not_authenticated():
+    client = CodexClient()
+
+    assert client.authenticated is False
+    assert client.account_info() == {
+        "authenticated": False,
+        "account_id": None,
+        "email": None,
+        "plan_type": None,
+    }
+
+
+
+def test_authenticate_non_interactive_uses_loaded_tokens(monkeypatch):
+    monkeypatch.setattr("codex_backend_sdk._client.load_tokens", lambda: _store())
+    monkeypatch.setattr("codex_backend_sdk._client.token_needs_refresh", lambda store: False)
+
+    client = CodexClient().authenticate(interactive=False)
+
+    assert client.authenticated is True
+    assert client.account_info()["email"] == "user@example.com"
+
+
+
+def test_authenticate_non_interactive_without_tokens_raises(monkeypatch):
+    monkeypatch.setattr("codex_backend_sdk._client.load_tokens", lambda: None)
+
+    try:
+        CodexClient().authenticate(interactive=False)
+    except RuntimeError as exc:
+        assert "interactive login required" in str(exc)
+    else:
+        raise AssertionError("Expected RuntimeError")

{codex_backend_sdk-0.3.3 → codex_backend_sdk-0.3.5}/tests/test_responses_resource.py

@@ -39,6 +39,7 @@ class FakeClient(OpenAI):
             return FakeJSONResponse({
                 "id": "resp_123",
                 "output": [{"type": "message", "content": []}],
+                "usage": {"input_tokens": 11, "output_tokens": 7, "total_tokens": 18},
             })
         return FakeSSE([
             'data: {"type":"response.content_part.delta","delta":{"text":"hel"}}',
@@ -282,6 +283,10 @@ def test_responses_compact_sends_shared_request_fields():
     )
 
     assert compacted.id == "resp_123"
+    assert compacted.usage is not None
+    assert compacted.usage.input_tokens == 11
+    assert compacted.usage.output_tokens == 7
+    assert compacted.usage.total_tokens == 18
     path, payload, stream = client.posts[0]
     assert path == "/responses/compact"
     assert stream is False
@@ -295,7 +300,7 @@ def test_responses_compact_sends_shared_request_fields():
                 "content": [{"type": "input_text", "text": "Long context"}],
             }
         ],
-        "tools": [{"type": "web_search_preview"}],
+        "tools": [{"type": "web_search"}],
         "parallel_tool_calls": True,
         "reasoning": {"effort": "medium"},
         "service_tier": "priority",