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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-backend-sdk
-Version: 0.3.2
+Version: 0.3.3
 Summary: Unofficial Python SDK for the ChatGPT Codex backend API
 License: MIT
 License-File: LICENSE
@@ -240,6 +240,30 @@ response = client.responses.create(
 )
 ```
 
+For structured output, `client.responses.parse(...)` accepts a Pydantic model,
+sends it as a strict JSON schema, and returns `ParsedResponse`:
+
+```python
+from pydantic import BaseModel
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+
+
+parsed = client.responses.parse(
+    model="gpt-5.4",
+    input="Extract: Ada is 37 years old.",
+    text_format=Person,
+)
+print(parsed.output_parsed.name)
+```
+
+Collected responses expose convenience properties for common output items:
+`response.output_text`, `response.reasoning_summary`, and
+`response.tool_calls`.
+
 Unsupported official Responses parameters are rejected explicitly with
 `CodexBackendUnsupportedParameterError`, including `temperature`, `top_p`,
 `max_output_tokens`, `metadata`, `user`, `safety_identifier`, `truncation`,

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

@@ -214,6 +214,30 @@ response = client.responses.create(
 )
 ```
 
+For structured output, `client.responses.parse(...)` accepts a Pydantic model,
+sends it as a strict JSON schema, and returns `ParsedResponse`:
+
+```python
+from pydantic import BaseModel
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+
+
+parsed = client.responses.parse(
+    model="gpt-5.4",
+    input="Extract: Ada is 37 years old.",
+    text_format=Person,
+)
+print(parsed.output_parsed.name)
+```
+
+Collected responses expose convenience properties for common output items:
+`response.output_text`, `response.reasoning_summary`, and
+`response.tool_calls`.
+
 Unsupported official Responses parameters are rejected explicitly with
 `CodexBackendUnsupportedParameterError`, including `temperature`, `top_p`,
 `max_output_tokens`, `metadata`, `user`, `safety_identifier`, `truncation`,

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

@@ -17,7 +17,7 @@ Quickstart:
     print(response.output_text)
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 
 from .oauth import run_oauth_flow, refresh_access_token, obtain_api_key
 from .storage import load_tokens, save_tokens, TokenStore
@@ -38,7 +38,9 @@ from .codex_client import (
     Model,
     RawMemory,
     RawMemoryMetadata,
+    ParsedResponse,
     Response,
+    ResponseFormatJsonSchema,
     ResponseStreamEvent,
     ResponseUsage,
     RealtimeCallResponse,
@@ -61,9 +63,11 @@ __all__ = [
     "MemorySummarizeOutput",
     "MemorySummarizeResponse",
     "Model",
+    "ParsedResponse",
     "RawMemory",
     "RawMemoryMetadata",
     "Response",
+    "ResponseFormatJsonSchema",
     "ResponseStreamEvent",
     "ResponseUsage",
     "RealtimeCallResponse",

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

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 import urllib.parse
-import time
 from typing import Any, Optional
 
 import requests
 
+from ._transport import request_with_retries
 from ._utils import _UNSET, _is_given
 from .storage import TokenStore, load_tokens, save_tokens, token_needs_refresh
 
@@ -271,37 +271,16 @@ class CodexClient:
         return response.json()
 
     def _request_with_retries(self, method: str, url: str, **kwargs: Any) -> requests.Response:
-        last_error: requests.RequestException | None = None
         use_session = kwargs.pop("_use_session", True)
-        for attempt in range(self._max_retries + 1):
-            try:
-                request = self._session.request if use_session else requests.request
-                response = request(method, url, **kwargs)
-                if self._should_retry_response(response, attempt):
-                    self._sleep_before_retry(response, attempt)
-                    continue
-                response.raise_for_status()
-                return response
-            except (requests.Timeout, requests.ConnectionError) as exc:
-                last_error = exc
-                if attempt >= self._max_retries:
-                    raise
-                self._sleep_before_retry(None, attempt)
-        if last_error is not None:
-            raise last_error
-        raise RuntimeError("Request retry loop exhausted")
-
-    def _should_retry_response(self, response: requests.Response, attempt: int) -> bool:
-        if attempt >= self._max_retries:
-            return False
-        return response.status_code == 429 or 500 <= response.status_code < 600
-
-    def _sleep_before_retry(self, response: requests.Response | None, attempt: int) -> None:
-        retry_after = response.headers.get("Retry-After") if response is not None else None
-        delay = _parse_retry_after(retry_after)
-        if delay is None:
-            delay = self._retry_base_delay * (2 ** attempt)
-        time.sleep(delay)
+        return request_with_retries(
+            self._session,
+            method,
+            url,
+            max_retries=self._max_retries,
+            retry_base_delay=self._retry_base_delay,
+            use_session=use_session,
+            **kwargs,
+        )
 
     def realtime_websocket_url(self, *, model: str) -> str:
         """Return the official OpenAI Realtime WebSocket URL for Codex plugins."""
@@ -324,12 +303,3 @@ class CodexClient:
 
 
 OpenAI = CodexClient
-
-
-def _parse_retry_after(value: str | None) -> float | None:
-    if not value:
-        return None
-    try:
-        return max(0.0, float(value))
-    except ValueError:
-        return None

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Iterator
-from typing import Any, Literal, Optional
+from typing import Any, Generic, Literal, Optional, TypeVar
 
 import requests
 from pydantic import BaseModel, ConfigDict, Field
@@ -13,6 +13,7 @@ ReasoningEffort = Literal["minimal", "low", "medium", "high", "xhigh"]
 ReasoningSummary = Literal["concise", "detailed", "auto"]
 Verbosity = Literal["low", "medium", "high"]
 ServiceTier = Literal["flex", "priority"]
+ParsedT = TypeVar("ParsedT")
 
 
 class CodexBaseModel(BaseModel):
@@ -73,6 +74,14 @@ class ResponseUsage(CodexBaseModel):
     output_tokens_details: TokenDetails = Field(default_factory=TokenDetails)
 
 
+class ResponseFormatJsonSchema(CodexBaseModel):
+    type: Literal["json_schema"] = "json_schema"
+    name: str
+    schema_: dict[str, Any] = Field(alias="schema")
+    strict: Optional[bool] = None
+    description: Optional[str] = None
+
+
 class Response(CodexBaseModel):
     id: str
     created_at: float = Field(default_factory=time.time)
@@ -117,6 +126,49 @@ class Response(CodexBaseModel):
                         texts.append(content.get("text", ""))
         return "".join(texts)
 
+    @property
+    def reasoning_summary(self) -> str | None:
+        texts: list[str] = []
+        for output in self.output:
+            if output.get("type") == "reasoning":
+                for summary in output.get("summary", []):
+                    if isinstance(summary, dict):
+                        texts.append(summary.get("text", ""))
+        return "\n".join(text for text in texts if text) or None
+
+    @property
+    def tool_calls(self) -> list[dict[str, Any]]:
+        return [output for output in self.output if output.get("type") == "function_call"]
+
+
+class ParsedResponse(CodexBaseModel, Generic[ParsedT]):
+    response: Response
+    output_parsed: ParsedT
+
+    @property
+    def id(self) -> str:
+        return self.response.id
+
+    @property
+    def model(self) -> Optional[str]:
+        return self.response.model
+
+    @property
+    def output(self) -> list[dict[str, Any]]:
+        return self.response.output
+
+    @property
+    def output_text(self) -> str:
+        return self.response.output_text
+
+    @property
+    def status(self) -> Optional[str]:
+        return self.response.status
+
+    @property
+    def usage(self) -> Optional[ResponseUsage]:
+        return self.response.usage
+
 
 class ResponseStreamEvent(CodexBaseModel):
     type: str

codex_backend_sdk-0.3.3/codex_backend_sdk/_transport.py

@@ -0,0 +1,71 @@
+"""HTTP transport helpers shared by client resources."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import requests
+
+
+def request_with_retries(
+    session: requests.Session,
+    method: str,
+    url: str,
+    *,
+    max_retries: int,
+    retry_base_delay: float,
+    use_session: bool = True,
+    **kwargs: Any,
+) -> requests.Response:
+    last_error: requests.RequestException | None = None
+    for attempt in range(max_retries + 1):
+        try:
+            request = session.request if use_session else requests.request
+            response = request(method, url, **kwargs)
+            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()
+            return response
+        except (requests.Timeout, requests.ConnectionError) as exc:
+            last_error = exc
+            if attempt >= max_retries:
+                raise
+            sleep_before_retry(None, attempt, retry_base_delay=retry_base_delay)
+    if last_error is not None:
+        raise last_error
+    raise RuntimeError("Request retry loop exhausted")
+
+
+def should_retry_response(
+    response: requests.Response,
+    attempt: int,
+    *,
+    max_retries: int,
+) -> bool:
+    if attempt >= max_retries:
+        return False
+    return response.status_code == 429 or 500 <= response.status_code < 600
+
+
+def sleep_before_retry(
+    response: requests.Response | None,
+    attempt: int,
+    *,
+    retry_base_delay: float,
+) -> None:
+    retry_after = response.headers.get("Retry-After") if response is not None else None
+    delay = parse_retry_after(retry_after)
+    if delay is None:
+        delay = retry_base_delay * (2 ** attempt)
+    time.sleep(delay)
+
+
+def parse_retry_after(value: str | None) -> float | None:
+    if not value:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        return None

{codex_backend_sdk-0.3.2 → codex_backend_sdk-0.3.3}/codex_backend_sdk/_utils.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import base64
 import json
+from dataclasses import asdict, is_dataclass
 from typing import Any
 
 from pydantic import BaseModel
@@ -26,6 +27,8 @@ def image_b64(data: str, media_type: str = "image/jpeg") -> dict[str, str]:
 def _jsonable(value: Any) -> Any:
     if isinstance(value, BaseModel):
         return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+    if is_dataclass(value) and not isinstance(value, type):
+        return _jsonable(asdict(value))
     if isinstance(value, dict):
         return {key: _jsonable(item) for key, item in value.items()}
     if isinstance(value, list):

{codex_backend_sdk-0.3.2 → codex_backend_sdk-0.3.3}/codex_backend_sdk/codex_client.py

@@ -16,12 +16,14 @@ from ._models import (
     Model,
     MemorySummarizeOutput,
     MemorySummarizeResponse,
+    ParsedResponse,
     RawMemory,
     RawMemoryMetadata,
     ReasoningEffort,
     ReasoningSummary,
     RealtimeCallResponse,
     Response,
+    ResponseFormatJsonSchema,
     ResponseStreamEvent,
     ResponseUsage,
     ServiceTier,
@@ -45,11 +47,13 @@ __all__ = [
     "MemorySummarizeResponse",
     "Model",
     "OpenAI",
+    "ParsedResponse",
     "RawMemory",
     "RawMemoryMetadata",
     "ReasoningEffort",
     "ReasoningSummary",
     "Response",
+    "ResponseFormatJsonSchema",
     "ResponseStreamEvent",
     "ResponseUsage",
     "RealtimeCallResponse",

codex_backend_sdk-0.3.2/codex_backend_sdk/resources/responses.py → codex_backend_sdk-0.3.3/codex_backend_sdk/resources/_responses_payloads.py

@@ -1,150 +1,25 @@
-"""Responses resource."""
+"""Internal builders and collectors for the Codex Responses resource."""
 
 from __future__ import annotations
 
 import time
-from collections.abc import Iterable, Iterator
-from typing import Any, Optional, TYPE_CHECKING
+from collections.abc import Iterable
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
 from .._models import (
     CodexBaseModel,
-    CompactedResponse,
     Response,
+    ResponseFormatJsonSchema,
     ResponseStreamEvent,
     ResponseUsage,
     TokenDetails,
 )
-from .._streaming import stream_response_events
-from .._utils import _UNSET, _default, _is_given, _reject_backend_unsupported
+from .._utils import _UNSET, _default, _is_given, _jsonable
 
-if TYPE_CHECKING:
-    from .._client import CodexClient
 
-
-class Responses:
-    def __init__(self, client: CodexClient) -> None:
-        self._client = client
-
-    def create(
-        self,
-        *,
-        background: Any = _UNSET,
-        context_management: Any = _UNSET,
-        conversation: Any = _UNSET,
-        include: Any = _UNSET,
-        input: Any = _UNSET,
-        instructions: Any = _UNSET,
-        max_output_tokens: Any = _UNSET,
-        max_tool_calls: Any = _UNSET,
-        metadata: Any = _UNSET,
-        model: Any = _UNSET,
-        parallel_tool_calls: Any = _UNSET,
-        previous_response_id: Any = _UNSET,
-        prompt: Any = _UNSET,
-        prompt_cache_key: Any = _UNSET,
-        prompt_cache_retention: Any = _UNSET,
-        reasoning: Any = _UNSET,
-        safety_identifier: Any = _UNSET,
-        service_tier: Any = _UNSET,
-        store: Any = _UNSET,
-        stream: Any = _UNSET,
-        stream_options: Any = _UNSET,
-        temperature: Any = _UNSET,
-        text: Any = _UNSET,
-        tool_choice: Any = _UNSET,
-        tools: Any = _UNSET,
-        top_logprobs: Any = _UNSET,
-        top_p: Any = _UNSET,
-        truncation: Any = _UNSET,
-        user: Any = _UNSET,
-        extra_headers: Any = None,
-        extra_query: Any = None,
-        extra_body: Any = None,
-        timeout: Any = _UNSET,
-    ) -> Response | Iterator[ResponseStreamEvent]:
-        _reject_backend_unsupported(
-            background=background,
-            context_management=context_management,
-            conversation=conversation,
-            max_output_tokens=max_output_tokens,
-            max_tool_calls=max_tool_calls,
-            metadata=metadata,
-            previous_response_id=previous_response_id,
-            prompt=prompt,
-            prompt_cache_retention=prompt_cache_retention,
-            safety_identifier=safety_identifier,
-            stream_options=stream_options,
-            temperature=temperature,
-            top_logprobs=top_logprobs,
-            top_p=top_p,
-            truncation=truncation,
-            user=user,
-            extra_body=extra_body,
-        )
-
-        if _is_given(store) and store is not False:
-            raise NotImplementedError("The Codex backend only accepts store=False.")
-
-        request = _ResponsesCreateRequest.from_openai_params(
-            client_defaults=self._client._defaults,
-            input=input,
-            include=include,
-            instructions=instructions,
-            model=model,
-            parallel_tool_calls=parallel_tool_calls,
-            prompt_cache_key=prompt_cache_key,
-            reasoning=reasoning,
-            service_tier=service_tier,
-            text=text,
-            tool_choice=tool_choice,
-            tools=tools,
-        )
-        response = self._client._post("/responses", body=request.payload, stream=True)
-        events = stream_response_events(response)
-        stream_enabled = bool(stream) if _is_given(stream) else False
-
-        if stream_enabled:
-            return events
-        return _collect_response(events, request=request)
-
-    def compact(
-        self,
-        *,
-        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": 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", []))
-
-
-class _ResponsesCreateRequest(CodexBaseModel):
+class ResponsesCreateRequest(CodexBaseModel):
     model: str
     instructions: Optional[str]
     input: list[dict[str, Any]]
@@ -164,9 +39,9 @@ class _ResponsesCreateRequest(CodexBaseModel):
         *,
         client_defaults: dict[str, Any],
         **params: Any,
-    ) -> "_ResponsesCreateRequest":
-        input_items = _normalize_input(params["input"])
-        tools = _normalize_tools(params["tools"])
+    ) -> "ResponsesCreateRequest":
+        input_items = normalize_input(params["input"])
+        tools = normalize_tools(params["tools"])
         include = (
             []
             if not _is_given(params["include"]) or params["include"] is None
@@ -198,9 +73,9 @@ class _ResponsesCreateRequest(CodexBaseModel):
         if service_tier is not None:
             payload["service_tier"] = service_tier
         if reasoning is not None:
-            payload["reasoning"] = _normalize_reasoning(reasoning)
+            payload["reasoning"] = normalize_reasoning(reasoning)
         if text is not None:
-            payload["text"] = _normalize_text(text)
+            payload["text"] = normalize_text(text)
 
         return cls(
             model=payload["model"],
@@ -218,10 +93,10 @@ class _ResponsesCreateRequest(CodexBaseModel):
         )
 
 
-def _collect_response(
+def collect_response(
     events: Iterable[ResponseStreamEvent],
     *,
-    request: _ResponsesCreateRequest,
+    request: ResponsesCreateRequest,
 ) -> Response:
     output: list[dict[str, Any]] = []
     text_parts: list[str] = []
@@ -267,42 +142,18 @@ def _collect_response(
     )
 
 
-def _event_delta_text(event: ResponseStreamEvent) -> str:
-    delta = getattr(event, "delta", None)
-    if isinstance(delta, str):
-        return delta
-    if isinstance(delta, dict):
-        return delta.get("text", "")
-    return ""
-
-
-def _event_response_dict(event: ResponseStreamEvent) -> dict[str, Any]:
-    response = getattr(event, "response", None)
-    if isinstance(response, BaseModel):
-        return response.model_dump()
-    return response if isinstance(response, dict) else {}
-
-
-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 str(error)
-
-
-def _normalize_input(input_value: Any) -> list[dict[str, Any]]:
+def normalize_input(input_value: Any) -> list[dict[str, Any]]:
     if not _is_given(input_value) or input_value is None:
         return []
     if isinstance(input_value, str):
         return [_message("user", [{"type": "input_text", "text": input_value}])]
     if isinstance(input_value, list):
-        return [_normalize_input_item(item) for item in input_value]
-    return [_normalize_input_item(input_value)]
+        return [normalize_input_item(item) for item in input_value]
+    return [normalize_input_item(input_value)]
 
 
-def _normalize_input_item(item: Any) -> dict[str, Any]:
-    raw = dict(item)
+def normalize_input_item(item: Any) -> dict[str, Any]:
+    raw = _as_dict(item)
     if raw.get("type") and raw.get("type") != "message":
         return raw
     if "role" not in raw:
@@ -321,23 +172,20 @@ def _normalize_input_item(item: Any) -> dict[str, Any]:
     return _message(role, content)
 
 
-def _message(role: str, content: list[dict[str, Any]]) -> dict[str, Any]:
-    return {"type": "message", "role": role, "content": content}
-
-
-def _normalize_tools(tools: Any) -> list[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 = dict(tool)
+        item = _as_dict(tool)
         if item.get("type") == "web_search":
             item["type"] = "web_search_preview"
         normalized.append(item)
     return normalized
 
 
-def _normalize_reasoning(reasoning: Any) -> dict[str, Any]:
+def normalize_reasoning(reasoning: Any) -> dict[str, Any]:
+    reasoning = _jsonable(reasoning)
     if isinstance(reasoning, dict):
         return {key: value for key, value in reasoning.items() if value is not None}
     return {
@@ -347,8 +195,8 @@ def _normalize_reasoning(reasoning: Any) -> dict[str, Any]:
     }
 
 
-def _normalize_text(text: Any) -> dict[str, Any]:
-    text_dict = dict(text)
+def normalize_text(text: Any) -> dict[str, Any]:
+    text_dict = _as_dict(text)
     fmt = text_dict.get("format")
     if isinstance(fmt, dict) and fmt.get("type") == "json_schema":
         schema = fmt.get("schema")
@@ -363,6 +211,96 @@ def _normalize_text(text: Any) -> dict[str, Any]:
     return text_dict
 
 
+def merge_text_format(text: Any, fmt: ResponseFormatJsonSchema) -> dict[str, Any]:
+    if not _is_given(text) or text is None:
+        text_dict: dict[str, Any] = {}
+    else:
+        text_dict = normalize_text(text)
+    if text_dict.get("format") is not None:
+        raise TypeError("Cannot pass both text_format and text.format.")
+    text_dict["format"] = fmt.model_dump(mode="json", by_alias=True, exclude_none=True)
+    return text_dict
+
+
+def pydantic_to_format(model_class: type[Any]) -> ResponseFormatJsonSchema:
+    try:
+        schema = model_class.model_json_schema()
+        model_class.model_validate_json
+    except AttributeError:
+        raise TypeError("responses.parse() requires a Pydantic BaseModel class.") from None
+
+    schema = _ensure_strict_schema(schema)
+    return ResponseFormatJsonSchema(
+        name=getattr(model_class, "__name__", "output"),
+        schema=schema,
+        strict=True,
+    )
+
+
+def _event_delta_text(event: ResponseStreamEvent) -> str:
+    delta = getattr(event, "delta", None)
+    if isinstance(delta, str):
+        return delta
+    if isinstance(delta, dict):
+        return delta.get("text", "")
+    return ""
+
+
+def _event_response_dict(event: ResponseStreamEvent) -> dict[str, Any]:
+    response = getattr(event, "response", None)
+    if isinstance(response, BaseModel):
+        return response.model_dump()
+    return response if isinstance(response, dict) else {}
+
+
+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 str(error)
+
+
+def _message(role: str, content: list[dict[str, Any]]) -> dict[str, Any]:
+    return {"type": "message", "role": role, "content": content}
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    value = _jsonable(value)
+    if isinstance(value, dict):
+        return value
+    return dict(value)
+
+
+def _ensure_strict_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    schema = dict(schema)
+    if schema.get("type") == "object":
+        schema.setdefault("additionalProperties", False)
+        props = schema.get("properties")
+        if isinstance(props, dict):
+            schema["properties"] = {
+                key: _ensure_strict_schema(value) if isinstance(value, dict) else value
+                for key, value in props.items()
+            }
+    items = schema.get("items")
+    if isinstance(items, dict):
+        schema["items"] = _ensure_strict_schema(items)
+    for key in ("anyOf", "oneOf", "allOf"):
+        variants = schema.get(key)
+        if isinstance(variants, list):
+            schema[key] = [
+                _ensure_strict_schema(value) if isinstance(value, dict) else value
+                for value in variants
+            ]
+    defs = schema.get("$defs")
+    if isinstance(defs, dict):
+        schema["$defs"] = {
+            key: _ensure_strict_schema(value) if isinstance(value, dict) else value
+            for key, value in defs.items()
+        }
+    return schema
+
+
 def _usage_from_backend(raw: Any) -> ResponseUsage:
     raw = raw or {}
     return ResponseUsage(

codex_backend_sdk-0.3.3/codex_backend_sdk/resources/responses.py

@@ -0,0 +1,224 @@
+"""Responses resource."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, TYPE_CHECKING
+
+from .._models import CompactedResponse, ParsedResponse, Response, ResponseStreamEvent
+from .._streaming import stream_response_events
+from .._utils import _UNSET, _default, _is_given, _reject_backend_unsupported
+from ._responses_payloads import (
+    ResponsesCreateRequest,
+    collect_response,
+    merge_text_format,
+    normalize_input_item,
+    normalize_reasoning,
+    normalize_text,
+    normalize_tools,
+    pydantic_to_format,
+)
+
+if TYPE_CHECKING:
+    from .._client import CodexClient
+
+
+class Responses:
+    def __init__(self, client: CodexClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        background: Any = _UNSET,
+        context_management: Any = _UNSET,
+        conversation: Any = _UNSET,
+        include: Any = _UNSET,
+        input: Any = _UNSET,
+        instructions: Any = _UNSET,
+        max_output_tokens: Any = _UNSET,
+        max_tool_calls: Any = _UNSET,
+        metadata: Any = _UNSET,
+        model: Any = _UNSET,
+        parallel_tool_calls: Any = _UNSET,
+        previous_response_id: Any = _UNSET,
+        prompt: Any = _UNSET,
+        prompt_cache_key: Any = _UNSET,
+        prompt_cache_retention: Any = _UNSET,
+        reasoning: Any = _UNSET,
+        safety_identifier: Any = _UNSET,
+        service_tier: Any = _UNSET,
+        store: Any = _UNSET,
+        stream: Any = _UNSET,
+        stream_options: Any = _UNSET,
+        temperature: Any = _UNSET,
+        text: Any = _UNSET,
+        tool_choice: Any = _UNSET,
+        tools: Any = _UNSET,
+        top_logprobs: Any = _UNSET,
+        top_p: Any = _UNSET,
+        truncation: Any = _UNSET,
+        user: Any = _UNSET,
+        extra_headers: Any = None,
+        extra_query: Any = None,
+        extra_body: Any = None,
+        timeout: Any = _UNSET,
+    ) -> Response | Iterator[ResponseStreamEvent]:
+        _reject_backend_unsupported(
+            background=background,
+            context_management=context_management,
+            conversation=conversation,
+            max_output_tokens=max_output_tokens,
+            max_tool_calls=max_tool_calls,
+            metadata=metadata,
+            previous_response_id=previous_response_id,
+            prompt=prompt,
+            prompt_cache_retention=prompt_cache_retention,
+            safety_identifier=safety_identifier,
+            stream_options=stream_options,
+            temperature=temperature,
+            top_logprobs=top_logprobs,
+            top_p=top_p,
+            truncation=truncation,
+            user=user,
+            extra_body=extra_body,
+        )
+
+        if _is_given(store) and store is not False:
+            raise NotImplementedError("The Codex backend only accepts store=False.")
+
+        request = ResponsesCreateRequest.from_openai_params(
+            client_defaults=self._client._defaults,
+            input=input,
+            include=include,
+            instructions=instructions,
+            model=model,
+            parallel_tool_calls=parallel_tool_calls,
+            prompt_cache_key=prompt_cache_key,
+            reasoning=reasoning,
+            service_tier=service_tier,
+            text=text,
+            tool_choice=tool_choice,
+            tools=tools,
+        )
+        response = self._client._post("/responses", body=request.payload, stream=True)
+        events = stream_response_events(response)
+        stream_enabled = bool(stream) if _is_given(stream) else False
+
+        if stream_enabled:
+            return events
+        return collect_response(events, request=request)
+
+    def parse(
+        self,
+        *,
+        text_format: type[Any],
+        background: Any = _UNSET,
+        context_management: Any = _UNSET,
+        conversation: Any = _UNSET,
+        include: Any = _UNSET,
+        input: Any = _UNSET,
+        instructions: Any = _UNSET,
+        max_output_tokens: Any = _UNSET,
+        max_tool_calls: Any = _UNSET,
+        metadata: Any = _UNSET,
+        model: Any = _UNSET,
+        parallel_tool_calls: Any = _UNSET,
+        previous_response_id: Any = _UNSET,
+        prompt: Any = _UNSET,
+        prompt_cache_key: Any = _UNSET,
+        prompt_cache_retention: Any = _UNSET,
+        reasoning: Any = _UNSET,
+        safety_identifier: Any = _UNSET,
+        service_tier: Any = _UNSET,
+        store: Any = _UNSET,
+        stream_options: Any = _UNSET,
+        temperature: Any = _UNSET,
+        text: Any = _UNSET,
+        tool_choice: Any = _UNSET,
+        tools: Any = _UNSET,
+        top_logprobs: Any = _UNSET,
+        top_p: Any = _UNSET,
+        truncation: Any = _UNSET,
+        user: Any = _UNSET,
+        extra_headers: Any = None,
+        extra_query: Any = None,
+        extra_body: Any = None,
+        timeout: Any = _UNSET,
+    ) -> ParsedResponse[Any]:
+        fmt = pydantic_to_format(text_format)
+        response = self.create(
+            background=background,
+            context_management=context_management,
+            conversation=conversation,
+            include=include,
+            input=input,
+            instructions=instructions,
+            max_output_tokens=max_output_tokens,
+            max_tool_calls=max_tool_calls,
+            metadata=metadata,
+            model=model,
+            parallel_tool_calls=parallel_tool_calls,
+            previous_response_id=previous_response_id,
+            prompt=prompt,
+            prompt_cache_key=prompt_cache_key,
+            prompt_cache_retention=prompt_cache_retention,
+            reasoning=reasoning,
+            safety_identifier=safety_identifier,
+            service_tier=service_tier,
+            store=store,
+            stream=False,
+            stream_options=stream_options,
+            temperature=temperature,
+            text=merge_text_format(text, fmt),
+            tool_choice=tool_choice,
+            tools=tools,
+            top_logprobs=top_logprobs,
+            top_p=top_p,
+            truncation=truncation,
+            user=user,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        if not isinstance(response, Response):
+            raise TypeError("responses.parse() expected a non-streaming Response")
+        return ParsedResponse(
+            response=response,
+            output_parsed=text_format.model_validate_json(response.output_text),
+        )
+
+    def compact(
+        self,
+        *,
+        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": 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.2 → codex_backend_sdk-0.3.3}/docs/backend-api.md

@@ -84,6 +84,10 @@ backend never returns a non-streaming HTTP response. In SDK calls,
 
 **SDK method**: `client.responses.create(...)`
 
+`client.responses.parse(..., text_format=MyPydanticModel)` is a convenience
+wrapper over the same endpoint. It populates `text.format` with a strict JSON
+schema and returns `ParsedResponse`.
+
 **Request body** (JSON):
 
 ```json

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

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

{codex_backend_sdk-0.3.2 → codex_backend_sdk-0.3.3}/tests/test_client_retry.py

@@ -1,6 +1,6 @@
 import requests
 
-import codex_backend_sdk._client as client_module
+import codex_backend_sdk._transport as transport_module
 from codex_backend_sdk import OpenAI
 
 
@@ -37,7 +37,7 @@ def _response(status_code, *, body=b"{}", headers=None):
 
 def test_retry_retries_5xx_then_returns_success(monkeypatch):
     sleeps = []
-    monkeypatch.setattr(client_module.time, "sleep", sleeps.append)
+    monkeypatch.setattr(transport_module.time, "sleep", sleeps.append)
     client = RetryClient([
         _response(503),
         _response(200, body=b'{"ok": true}'),
@@ -52,7 +52,7 @@ def test_retry_retries_5xx_then_returns_success(monkeypatch):
 
 def test_retry_honors_retry_after_header(monkeypatch):
     sleeps = []
-    monkeypatch.setattr(client_module.time, "sleep", sleeps.append)
+    monkeypatch.setattr(transport_module.time, "sleep", sleeps.append)
     client = RetryClient([
         _response(429, headers={"Retry-After": "1.5"}),
         _response(200),
@@ -66,7 +66,7 @@ def test_retry_honors_retry_after_header(monkeypatch):
 
 def test_retry_does_not_retry_client_errors(monkeypatch):
     sleeps = []
-    monkeypatch.setattr(client_module.time, "sleep", sleeps.append)
+    monkeypatch.setattr(transport_module.time, "sleep", sleeps.append)
     client = RetryClient([
         _response(400, body=b'{"error": "bad request"}'),
     ])
@@ -84,7 +84,7 @@ def test_retry_does_not_retry_client_errors(monkeypatch):
 
 def test_retry_retries_transport_timeout(monkeypatch):
     sleeps = []
-    monkeypatch.setattr(client_module.time, "sleep", sleeps.append)
+    monkeypatch.setattr(transport_module.time, "sleep", sleeps.append)
     client = RetryClient([
         requests.Timeout("temporary timeout"),
         _response(200, body=b'{"ok": true}'),

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

@@ -1,4 +1,8 @@
-from codex_backend_sdk import OpenAI, Response
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from codex_backend_sdk import OpenAI, ParsedResponse, Response
 
 
 class FakeSSE:
@@ -75,6 +79,34 @@ class FakeClient(OpenAI):
         )
 
 
+class ParsedPerson(BaseModel):
+    name: str
+    age: int
+
+
+@dataclass
+class TextOptions:
+    verbosity: str
+
+
+class ParseFakeClient(FakeClient):
+    def _post(self, path, *, body, stream=False):
+        self.posts.append((path, body, stream))
+        return FakeSSE([
+            (
+                'data: {"type":"response.output_text.delta","delta":'
+                '"{\\"name\\":\\"Ada\\",\\"age\\":37}"}'
+            ),
+            "",
+            (
+                'data: {"type":"response.completed","response":'
+                '{"id":"resp_parse","model":"gpt-test","output":[{"type":"message",'
+                '"role":"assistant","content":[{"type":"output_text",'
+                '"text":"{\\"name\\":\\"Ada\\",\\"age\\":37}"}]}]}}'
+            ),
+        ])
+
+
 def test_responses_create_collects_to_pydantic_response():
     client = FakeClient()
 
@@ -107,6 +139,75 @@ def test_responses_create_collects_to_pydantic_response():
     assert payload["text"] == {"verbosity": "low"}
 
 
+def test_response_exposes_tool_calls_and_reasoning_summary():
+    response = Response(
+        id="resp_helpers",
+        output=[
+            {
+                "type": "reasoning",
+                "summary": [
+                    {"type": "summary_text", "text": "First"},
+                    {"type": "summary_text", "text": "Second"},
+                ],
+            },
+            {
+                "type": "function_call",
+                "call_id": "call_123",
+                "name": "lookup",
+                "arguments": "{}",
+            },
+        ],
+    )
+
+    assert response.reasoning_summary == "First\nSecond"
+    assert response.tool_calls == [
+        {
+            "type": "function_call",
+            "call_id": "call_123",
+            "name": "lookup",
+            "arguments": "{}",
+        }
+    ]
+
+
+def test_responses_parse_sends_strict_schema_and_returns_parsed_response():
+    client = ParseFakeClient()
+
+    parsed = client.responses.parse(
+        model="gpt-test",
+        input="Extract the person",
+        text_format=ParsedPerson,
+        text=TextOptions(verbosity="low"),
+    )
+
+    assert isinstance(parsed, ParsedResponse)
+    assert parsed.id == "resp_parse"
+    assert parsed.output_parsed == ParsedPerson(name="Ada", age=37)
+    path, payload, stream = client.posts[0]
+    assert path == "/responses"
+    assert stream is True
+    assert payload["text"]["verbosity"] == "low"
+    assert payload["text"]["format"]["type"] == "json_schema"
+    assert payload["text"]["format"]["name"] == "ParsedPerson"
+    assert payload["text"]["format"]["strict"] is True
+    assert payload["text"]["format"]["schema"]["additionalProperties"] is False
+
+
+def test_responses_parse_rejects_existing_text_format():
+    client = ParseFakeClient()
+
+    try:
+        client.responses.parse(
+            input="Extract",
+            text_format=ParsedPerson,
+            text={"format": {"type": "json_object"}},
+        )
+    except TypeError as exc:
+        assert "text_format" in str(exc)
+    else:
+        raise AssertionError("Expected TypeError")
+
+
 def test_responses_create_normalizes_official_input_items():
     client = FakeClient()