codex-sdk-python 0.98.0__tar.gz → 0.104.0__tar.gz

{codex_sdk_python-0.98.0 → codex_sdk_python-0.104.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codex-sdk-python
-Version: 0.98.0
+Version: 0.104.0
 Summary: Python SDK for the Codex CLI agent with async threads, streaming events, and structured outputs
 Keywords: codex,sdk,python,api,cli,agent,async,streaming
 Author: Vectorfy Co
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Build Tools
-Requires-Dist: logfire-api>=4 ; extra == 'logfire'
+Requires-Dist: logfire ; extra == 'logfire'
 Requires-Dist: pydantic>=2 ; extra == 'pydantic'
 Requires-Dist: pydantic-ai ; python_full_version >= '3.10' and extra == 'pydantic-ai'
 Maintainer: Vectorfy Co
@@ -44,7 +44,7 @@ Embed the Codex agent in Python workflows. This SDK wraps the bundled `codex` CL
       <td><strong>Lifecycle</strong></td>
       <td>
         <a href="#ci-cd"><img src="https://img.shields.io/badge/CI%2FCD-Active-16a34a?style=flat&logo=githubactions&logoColor=white" alt="CI/CD badge" /></a>
-        <img src="https://img.shields.io/badge/Release-0.98.0-6b7280?style=flat&logo=pypi&logoColor=white" alt="Release badge" />
+        <img src="https://img.shields.io/badge/Release-0.104.0-6b7280?style=flat&logo=pypi&logoColor=white" alt="Release 0.104.0 badge" />
         <a href="#license"><img src="https://img.shields.io/badge/License-Apache--2.0-0f766e?style=flat&logo=apache&logoColor=white" alt="License badge" /></a>
       </td>
     </tr>
@@ -366,8 +366,21 @@ for payload shapes and event semantics.
 Note: some endpoints and fields are gated behind an experimental capability; set
 `AppServerOptions(experimental_api_enabled=True)` to opt in.
 
-`thread_list` supports `archived`, `sort_key`, and `source_kinds` filters, and `config_read` accepts an optional `cwd`
-to compute the effective layered config for a specific working directory.
+`thread_list` supports `archived`, `sort_key`, and `source_kinds` filters (unchanged), and now also accepts `cwd`
+for scoped thread queries. `config_read` accepts an optional `cwd` to compute effective layered config for a specific
+working directory.
+
+`skills_remote_read` supports `cwds`, `enabled`, `hazelnut_scope`, and `product_surface` filters. `model_list` accepts
+an optional `include_hidden` flag.
+
+```python
+threads = await app.thread_list(archived=False, sort_key="updatedAt", source_kinds=["local"], cwd=".")
+config = await app.config_read(include_layers=True, cwd=".")
+skills = await app.skills_remote_read(
+    cwds=["."], enabled=True, hazelnut_scope="user", product_surface="codex_desktop"
+)
+models = await app.model_list(limit=20, include_hidden=False)
+```
 
 ### Observability (OTEL) and notify
 
@@ -410,8 +423,9 @@ Supported target triples:
 - macOS: `x86_64-apple-darwin`, `aarch64-apple-darwin`
 - Windows: `x86_64-pc-windows-msvc`, `aarch64-pc-windows-msvc`
 
-If you are working from source and the vendor directory is missing, run `python scripts/setup_binary.py`
-or follow `SETUP.md` to download the official npm package and copy the `vendor/` directory.
+If you are working from source and the vendor directory is missing, run
+`python scripts/setup_binary.py` to fetch and assemble the platform `@openai/codex`
+artifacts into `src/codex_sdk/vendor/`.
 
 <a id="auth"></a>
 ## ![Auth](https://img.shields.io/badge/Auth%20%26%20Credentials-Access-2563eb?style=for-the-badge&logo=gnubash&logoColor=white)

{codex_sdk_python-0.98.0 → codex_sdk_python-0.104.0}/README.md

@@ -8,7 +8,7 @@ Embed the Codex agent in Python workflows. This SDK wraps the bundled `codex` CL
       <td><strong>Lifecycle</strong></td>
       <td>
         <a href="#ci-cd"><img src="https://img.shields.io/badge/CI%2FCD-Active-16a34a?style=flat&logo=githubactions&logoColor=white" alt="CI/CD badge" /></a>
-        <img src="https://img.shields.io/badge/Release-0.98.0-6b7280?style=flat&logo=pypi&logoColor=white" alt="Release badge" />
+        <img src="https://img.shields.io/badge/Release-0.104.0-6b7280?style=flat&logo=pypi&logoColor=white" alt="Release 0.104.0 badge" />
         <a href="#license"><img src="https://img.shields.io/badge/License-Apache--2.0-0f766e?style=flat&logo=apache&logoColor=white" alt="License badge" /></a>
       </td>
     </tr>
@@ -330,8 +330,21 @@ for payload shapes and event semantics.
 Note: some endpoints and fields are gated behind an experimental capability; set
 `AppServerOptions(experimental_api_enabled=True)` to opt in.
 
-`thread_list` supports `archived`, `sort_key`, and `source_kinds` filters, and `config_read` accepts an optional `cwd`
-to compute the effective layered config for a specific working directory.
+`thread_list` supports `archived`, `sort_key`, and `source_kinds` filters (unchanged), and now also accepts `cwd`
+for scoped thread queries. `config_read` accepts an optional `cwd` to compute effective layered config for a specific
+working directory.
+
+`skills_remote_read` supports `cwds`, `enabled`, `hazelnut_scope`, and `product_surface` filters. `model_list` accepts
+an optional `include_hidden` flag.
+
+```python
+threads = await app.thread_list(archived=False, sort_key="updatedAt", source_kinds=["local"], cwd=".")
+config = await app.config_read(include_layers=True, cwd=".")
+skills = await app.skills_remote_read(
+    cwds=["."], enabled=True, hazelnut_scope="user", product_surface="codex_desktop"
+)
+models = await app.model_list(limit=20, include_hidden=False)
+```
 
 ### Observability (OTEL) and notify
 
@@ -374,8 +387,9 @@ Supported target triples:
 - macOS: `x86_64-apple-darwin`, `aarch64-apple-darwin`
 - Windows: `x86_64-pc-windows-msvc`, `aarch64-pc-windows-msvc`
 
-If you are working from source and the vendor directory is missing, run `python scripts/setup_binary.py`
-or follow `SETUP.md` to download the official npm package and copy the `vendor/` directory.
+If you are working from source and the vendor directory is missing, run
+`python scripts/setup_binary.py` to fetch and assemble the platform `@openai/codex`
+artifacts into `src/codex_sdk/vendor/`.
 
 <a id="auth"></a>
 ## ![Auth](https://img.shields.io/badge/Auth%20%26%20Credentials-Access-2563eb?style=for-the-badge&logo=gnubash&logoColor=white)

{codex_sdk_python-0.98.0 → codex_sdk_python-0.104.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.9.21,<0.10.0"]
+requires = ["uv_build>=0.9.21,<0.11.0"]
 build-backend = "uv_build"
 
 [project]
 name = "codex-sdk-python"
-version = "0.98.0"
+version = "0.104.0"
 description = "Python SDK for the Codex CLI agent with async threads, streaming events, and structured outputs"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -40,10 +40,7 @@ pydantic-ai = [
     "pydantic-ai; python_version >= '3.10'",
 ]
 logfire = [
-    # `pydantic-ai` imports the `logfire` module, which is provided by the
-    # `logfire-api` distribution. Avoid the unrelated legacy `logfire` package
-    # on PyPI which can shadow it and break imports.
-    "logfire-api>=4",
+    "logfire",
 ]
 
 [dependency-groups]

{codex_sdk_python-0.98.0 → codex_sdk_python-0.104.0}/src/codex_sdk/__init__.py

@@ -15,6 +15,8 @@ from .app_server import (
     AppServerRequest,
     AppServerTurnSession,
     AppServerUserInput,
+    SkillsRemoteReadRequest,
+    SkillsRemoteWriteRequest,
 )
 from .codex import Codex
 from .events import (
@@ -41,11 +43,6 @@ from .exceptions import (
 from .hooks import ThreadHooks
 from .items import (
     AgentMessageItem,
-    CollabAgentState,
-    CollabAgentStatus,
-    CollabTool,
-    CollabToolCallItem,
-    CollabToolCallStatus,
     CommandExecutionItem,
     CommandExecutionStatus,
     ErrorItem,
@@ -82,7 +79,7 @@ from .thread import (
     Turn,
 )
 
-__version__ = "0.98.0"
+__version__ = "0.104.0"
 
 __all__ = [
     "AbortController",
@@ -97,6 +94,8 @@ __all__ = [
     "ApprovalDecisions",
     "AppServerInput",
     "AppServerUserInput",
+    "SkillsRemoteReadRequest",
+    "SkillsRemoteWriteRequest",
     "Thread",
     "ThreadHooks",
     "Input",
@@ -122,7 +121,6 @@ __all__ = [
     "CommandExecutionItem",
     "FileChangeItem",
     "McpToolCallItem",
-    "CollabToolCallItem",
     "McpToolCallItemResult",
     "McpToolCallItemError",
     "WebSearchItem",
@@ -132,10 +130,6 @@ __all__ = [
     "PatchChangeKind",
     "PatchApplyStatus",
     "McpToolCallStatus",
-    "CollabToolCallStatus",
-    "CollabTool",
-    "CollabAgentStatus",
-    "CollabAgentState",
     "TodoItem",
     "CodexOptions",
     "ThreadOptions",

{codex_sdk_python-0.98.0 → codex_sdk_python-0.104.0}/src/codex_sdk/app_server.py

@@ -558,6 +558,7 @@ class AppServerClient:
         model_providers: Optional[Sequence[str]] = None,
         source_kinds: Optional[Sequence[str]] = None,
         archived: Optional[bool] = None,
+        cwd: Optional[Union[str, Path]] = None,
     ) -> Dict[str, Any]:
         """
         Retrieve a page of threads from the app-server with optional filtering and sorting.
@@ -570,6 +571,7 @@ class AppServerClient:
             source_kinds: Filter threads by one or more source kinds.
             archived: If set, restrict results to archived (`True`) or unarchived (`False`)
                 threads.
+            cwd: Optional working directory scope for server-side filtering.
 
         Returns:
             The raw response dictionary returned by the app-server for the `thread/list`
@@ -588,6 +590,8 @@ class AppServerClient:
             params["source_kinds"] = list(source_kinds)
         if archived is not None:
             params["archived"] = archived
+        if cwd is not None:
+            params["cwd"] = str(cwd)
         return await self._request_dict("thread/list", _coerce_keys(params) or None)
 
     async def thread_read(
@@ -636,14 +640,41 @@ class AppServerClient:
         """
         return await self._request_dict("thread/unarchive", {"threadId": thread_id})
 
-    async def thread_compact_start(self, thread_id: str) -> Dict[str, Any]:
+    async def thread_compact_start(
+        self, thread_id: str, *, instructions: Optional[str] = None
+    ) -> Dict[str, Any]:
         """
         Starts a compaction operation for the specified thread on the app-server.
 
+        Args:
+            thread_id: Identifier of the thread to compact.
+            instructions: Optional server hint for compaction behavior.
+
         Returns:
             dict: The app-server's result payload for the compaction start request.
         """
-        return await self._request_dict("thread/compact/start", {"threadId": thread_id})
+        payload: Dict[str, Any] = {"thread_id": thread_id}
+        if instructions is not None:
+            payload["instructions"] = instructions
+        return await self._request_dict("thread/compact/start", _coerce_keys(payload))
+
+    async def thread_background_terminals_clean(
+        self, thread_id: str, *, terminal_ids: Sequence[str]
+    ) -> Dict[str, Any]:
+        """
+        Clean up background terminal sessions for a thread.
+
+        Args:
+            thread_id: Identifier of the thread.
+            terminal_ids: Terminal ids to clean.
+
+        Returns:
+            App-server response payload.
+        """
+        payload = {"thread_id": thread_id, "terminal_ids": list(terminal_ids)}
+        return await self._request_dict(
+            "thread/backgroundTerminals/clean", _coerce_keys(payload)
+        )
 
     async def thread_rollback(
         self, thread_id: str, *, num_turns: int
@@ -741,43 +772,110 @@ class AppServerClient:
             payload["cwds"] = [str(path) for path in cwds]
         return await self._request_dict("skills/list", _coerce_keys(payload))
 
-    async def skills_remote_read(self) -> Dict[str, Any]:
+    async def skills_remote_read(
+        self,
+        *,
+        cwds: Optional[Sequence[Union[str, Path]]] = None,
+        enabled: Optional[bool] = None,
+        hazelnut_scope: Optional[str] = None,
+        product_surface: Optional[str] = None,
+        params: Optional["SkillsRemoteReadRequest"] = None,
+    ) -> Dict[str, Any]:
         """
         Read remote skills metadata from the app server.
 
+        Args:
+            cwds: Optional workspace roots to scope the remote skill listing.
+            enabled: Optional filter for enabled/disabled remote skills.
+            hazelnut_scope: Optional Hazelnut scope identifier.
+            product_surface: Optional product surface identifier.
+            params: Optional raw request payload for protocol-forward fields.
+
         Returns:
             result (Dict[str, Any]): The app-server response payload for the `skills/remote/read` request.
         """
-        return await self._request_dict("skills/remote/read", {})
+        payload: Dict[str, Any] = {}
+        if params is not None:
+            _validate_alias_conflicts(
+                params,
+                (
+                    ("hazelnut_scope", "hazelnutScope"),
+                    ("product_surface", "productSurface"),
+                ),
+                context="SkillsRemoteReadRequest",
+            )
+            payload.update(dict(params))
+        if cwds is not None:
+            payload["cwds"] = [str(path) for path in cwds]
+        if enabled is not None:
+            payload["enabled"] = enabled
+        if hazelnut_scope is not None:
+            payload["hazelnut_scope"] = hazelnut_scope
+        if product_surface is not None:
+            payload["product_surface"] = product_surface
+        return await self._request_dict("skills/remote/read", _coerce_keys(payload))
 
     async def skills_remote_write(
-        self, *, hazelnut_id: str, is_preload: bool
+        self,
+        *,
+        hazelnut_id: Optional[str] = None,
+        is_preload: Optional[bool] = None,
+        params: Optional["SkillsRemoteWriteRequest"] = None,
     ) -> Dict[str, Any]:
         """
-        Start a remote skill write operation for a Hazelnut package.
+        Start a remote skill write operation.
 
         Args:
-            hazelnut_id: Identifier of the remote Hazelnut skill to write.
-            is_preload: Whether the skill should be marked as a preload.
+            hazelnut_id: Optional Hazelnut identifier.
+            is_preload: Optional preload flag.
+            params: Optional raw request payload.
 
         Returns:
             Result returned by the app-server for the "skills/remote/write" request.
         """
-        payload = {"hazelnut_id": hazelnut_id, "is_preload": is_preload}
+        payload: Dict[str, Any] = {}
+        if params is not None:
+            _validate_alias_conflicts(
+                params,
+                (
+                    ("hazelnut_id", "hazelnutId"),
+                    ("is_preload", "isPreload"),
+                ),
+                context="SkillsRemoteWriteRequest",
+            )
+            payload.update(dict(params))
+        if hazelnut_id is not None:
+            payload["hazelnut_id"] = hazelnut_id
+        if is_preload is not None:
+            payload["is_preload"] = is_preload
         return await self._request_dict("skills/remote/write", _coerce_keys(payload))
 
-    async def skills_config_write(self, *, path: str, enabled: bool) -> Dict[str, Any]:
+    async def skills_config_write(
+        self,
+        *,
+        path: Optional[str] = None,
+        enabled: Optional[bool] = None,
+        params: Optional["SkillsConfigWriteRequest"] = None,
+    ) -> Dict[str, Any]:
         """
-        Set the enabled state of a skill configuration at the given path.
+        Set skill configuration state.
 
         Args:
-            path: The configuration path identifying the skill.
-            enabled: True to enable the skill at the path, False to disable it.
+            path: Optional configuration path identifying the skill.
+            enabled: Optional enabled state for the skill.
+            params: Optional typed request payload for evolving protocol fields.
 
         Returns:
             The app-server response as a dictionary.
         """
-        payload = {"path": path, "enabled": enabled}
+        # TODO(app-server-schema): tighten request shape after protocol stabilizes.
+        payload: Dict[str, Any] = {}
+        if params is not None:
+            payload.update(_coerce_keys(dict(params)))
+        if path is not None:
+            payload["path"] = path
+        if enabled is not None:
+            payload["enabled"] = enabled
         return await self._request_dict("skills/config/write", payload)
 
     async def turn_start(
@@ -848,8 +946,29 @@ class AppServerClient:
             "turn/interrupt", {"threadId": thread_id, "turnId": turn_id}
         )
 
+    async def turn_steer(
+        self, thread_id: str, turn_id: str, *, prompt: str
+    ) -> Dict[str, Any]:
+        """
+        Send steering guidance to an in-progress turn.
+
+        Args:
+            thread_id: Identifier of the thread.
+            turn_id: Identifier of the turn.
+            prompt: Steering prompt text.
+
+        Returns:
+            App-server response payload.
+        """
+        payload = {"thread_id": thread_id, "turn_id": turn_id, "prompt": prompt}
+        return await self._request_dict("turn/steer", _coerce_keys(payload))
+
     async def model_list(
-        self, *, cursor: Optional[str] = None, limit: Optional[int] = None
+        self,
+        *,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+        include_hidden: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """List models available to the app-server."""
         params: Dict[str, Any] = {}
@@ -857,7 +976,9 @@ class AppServerClient:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = limit
-        return await self._request_dict("model/list", params or None)
+        if include_hidden is not None:
+            params["include_hidden"] = include_hidden
+        return await self._request_dict("model/list", _coerce_keys(params) or None)
 
     async def app_list(
         self, *, cursor: Optional[str] = None, limit: Optional[int] = None
@@ -874,6 +995,26 @@ class AppServerClient:
         """List supported collaboration modes from the app-server."""
         return await self._request_dict("collaborationMode/list", {})
 
+    async def experimental_feature_list(
+        self, *, cursor: Optional[str] = None, limit: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        List experimental features available from the app-server.
+
+        Args:
+            cursor: Optional pagination cursor.
+            limit: Optional page size.
+
+        Returns:
+            App-server response payload.
+        """
+        params: Dict[str, Any] = {}
+        if cursor is not None:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        return await self._request_dict("experimentalFeature/list", params or None)
+
     async def command_exec(
         self,
         *,
@@ -938,6 +1079,103 @@ class AppServerClient:
             "account/read", {"refreshToken": refresh_token} if refresh_token else None
         )
 
+    async def account_chatgpt_auth_tokens_refresh(
+        self, *, params: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Refresh ChatGPT auth tokens via the app-server.
+
+        Args:
+            params: Refresh payload (snake_case or camelCase keys are accepted).
+
+        Returns:
+            App-server response payload.
+        """
+        return await self._request_dict(
+            "account/chatgptAuthTokens/refresh", _coerce_keys(dict(params))
+        )
+
+    async def item_tool_call(self, *, params: "ItemToolCallRequest") -> Dict[str, Any]:
+        """
+        Send an item tool-call payload.
+
+        Args:
+            params: Typed request payload for `item/tool/call`.
+
+        Returns:
+            App-server response payload.
+        """
+        # TODO(app-server-schema): tighten request shape after protocol stabilizes.
+        return await self._request_dict("item/tool/call", _coerce_keys(dict(params)))
+
+    async def item_tool_request_user_input(
+        self, *, params: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Send an item request-user-input payload.
+
+        Args:
+            params: Request payload for `item/tool/requestUserInput`.
+
+        Returns:
+            App-server response payload.
+        """
+        return await self._request_dict(
+            "item/tool/requestUserInput", _coerce_keys(dict(params))
+        )
+
+    async def item_command_execution_request_approval(
+        self, *, params: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Send an item command-execution approval payload.
+
+        Args:
+            params: Request payload for `item/commandExecution/requestApproval`.
+
+        Returns:
+            App-server response payload.
+        """
+        return await self._request_dict(
+            "item/commandExecution/requestApproval", _coerce_keys(dict(params))
+        )
+
+    async def item_file_change_request_approval(
+        self, *, params: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Send an item file-change approval payload.
+
+        Args:
+            params: Request payload for `item/fileChange/requestApproval`.
+
+        Returns:
+            App-server response payload.
+        """
+        return await self._request_dict(
+            "item/fileChange/requestApproval", _coerce_keys(dict(params))
+        )
+
+    async def mock_experimental_method(
+        self, *, params: Optional[Mapping[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Call a mock experimental app-server endpoint.
+
+        Args:
+            params: Optional request payload.
+
+        Returns:
+            App-server response payload.
+        """
+        if not self._options.experimental_api_enabled:
+            raise CodexError(
+                "`mock/experimentalMethod` requires "
+                "AppServerOptions(experimental_api_enabled=True)."
+            )
+        payload = _coerce_keys(dict(params)) if params is not None else {}
+        return await self._request_dict("mock/experimentalMethod", payload)
+
     async def feedback_upload(
         self,
         *,
@@ -1109,6 +1347,46 @@ class AppServerSkillInput(TypedDict):
     path: str
 
 
+class SkillsConfigWriteRequest(TypedDict, total=False):
+    """Typed payload for `skills/config/write` requests."""
+
+    path: str
+    enabled: bool
+    mode: str
+
+
+class SkillsRemoteReadRequest(TypedDict, total=False):
+    """Typed payload for `skills/remote/read` requests."""
+
+    cwds: List[str]
+    enabled: bool
+    hazelnut_scope: str
+    hazelnutScope: str
+    product_surface: str
+    productSurface: str
+
+
+class SkillsRemoteWriteRequest(TypedDict, total=False):
+    """Typed payload for `skills/remote/write` requests."""
+
+    hazelnut_id: str
+    hazelnutId: str
+    is_preload: bool
+    isPreload: bool
+
+
+class ItemToolCallRequest(TypedDict, total=False):
+    """Typed payload for `item/tool/call` requests."""
+
+    name: str
+    tool_name: str
+    toolName: str
+    tool_call_id: str
+    toolCallId: str
+    arguments: Mapping[str, Any]
+    args: Mapping[str, Any]
+
+
 AppServerUserInput = Union[
     AppServerTextInput,
     AppServerImageInput,
@@ -1180,6 +1458,21 @@ def _coerce_keys(params: Mapping[str, Any]) -> Dict[str, Any]:
     return coerced
 
 
+def _validate_alias_conflicts(
+    params: Mapping[str, Any],
+    alias_pairs: Sequence[tuple[str, str]],
+    *,
+    context: str,
+) -> None:
+    """Reject payloads that provide both snake_case and camelCase aliases."""
+    for snake_case_key, camel_case_key in alias_pairs:
+        if snake_case_key in params and camel_case_key in params:
+            raise CodexError(
+                f"{context} received both '{snake_case_key}' and "
+                f"'{camel_case_key}'. Provide only one key variant."
+            )
+
+
 def _snake_to_camel(value: str) -> str:
     """Convert snake_case strings to lowerCamelCase."""
     parts = value.split("_")