codex-python 1.114.2__tar.gz → 1.131.0__tar.gz

{codex_python-1.114.2 → codex_python-1.131.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-python
-Version: 1.114.2
+Version: 1.131.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12

{codex_python-1.114.2 → codex_python-1.131.0}/codex/__init__.py

@@ -17,7 +17,7 @@ from codex.options import (
 )
 from codex.thread import CodexTurnStream, Input, Thread
 
-__version__ = "1.114.2"
+__version__ = "1.131.0"
 
 __all__ = [
     "Codex",

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/_async_services.py

@@ -26,6 +26,7 @@ from codex.app_server.models import (
     ModelInfo,
     ModelListResult,
     SkillsConfigWriteResult,
+    SkillsListEntry,
     SkillsListResult,
     WindowsSandboxSetupStartResult,
 )
@@ -112,13 +113,11 @@ class AsyncSkillsClient(_AsyncServiceClient):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
-    ) -> list[protocol.SkillsListEntry]:
+    ) -> list[SkillsListEntry]:
         return (
             await self.list_page(
                 cwds=cwds,
                 force_reload=force_reload,
-                per_cwd_extra_user_roots=per_cwd_extra_user_roots,
             )
         ).data
 
@@ -127,19 +126,18 @@ class AsyncSkillsClient(_AsyncServiceClient):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
     ) -> SkillsListResult:
         params = protocol.SkillsListParams(
             cwds=list(cwds) if cwds is not None else None,
             forceReload=force_reload,
-            perCwdExtraUserRoots=(
-                list(per_cwd_extra_user_roots) if per_cwd_extra_user_roots is not None else None
-            ),
         )
         return await self._rpc.request_typed("skills/list", params, SkillsListResult)
 
     async def write_config(self, *, path: str, enabled: bool) -> SkillsConfigWriteResult:
-        params = protocol.SkillsConfigWriteParams(path=path, enabled=enabled)
+        params = protocol.SkillsConfigWriteParams(
+            path=protocol.AbsolutePathBuf(path),
+            enabled=enabled,
+        )
         return await self._rpc.request_typed("skills/config/write", params, SkillsConfigWriteResult)
 
 
@@ -322,19 +320,80 @@ class AsyncCommandClient(_AsyncServiceClient):
         *,
         command: Sequence[str],
         cwd: str | None = None,
+        disable_output_cap: bool | None = None,
+        disable_timeout: bool | None = None,
+        env: Mapping[str, object | None] | None = None,
+        output_bytes_cap: int | None = None,
+        process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
+        size: protocol.CommandExecTerminalSize | None = None,
+        stream_stdin: bool | None = None,
+        stream_stdout_stderr: bool | None = None,
         timeout_ms: int | None = None,
+        tty: bool | None = None,
     ) -> CommandExecResult:
         params = protocol.CommandExecParams(
             command=list(command),
             cwd=cwd,
+            disableOutputCap=disable_output_cap,
+            disableTimeout=disable_timeout,
+            env=dict(env) if env is not None else None,
+            outputBytesCap=output_bytes_cap,
+            processId=process_id,
             sandboxPolicy=sandbox_policy,
+            size=size,
+            streamStdin=stream_stdin,
+            streamStdoutStderr=stream_stdout_stderr,
             timeoutMs=timeout_ms,
+            tty=tty,
         )
         return await self._rpc.request_typed("command/exec", params, CommandExecResult)
 
     exec = execute
 
+    async def write_stdin(
+        self,
+        *,
+        process_id: str,
+        close_stdin: bool | None = None,
+        delta_base64: str | None = None,
+    ) -> EmptyResult:
+        """Write stdin bytes to a running `command/exec` process or close stdin.
+
+        This wraps the app-server `command/exec/write` request. `delta_base64`
+        is optional base64-encoded stdin data; `close_stdin` closes the
+        process stdin after the optional write.
+        """
+        params = protocol.CommandExecWriteParams(
+            closeStdin=close_stdin,
+            deltaBase64=delta_base64,
+            processId=process_id,
+        )
+        return await self._rpc.request_typed("command/exec/write", params, EmptyResult)
+
+    async def resize_terminal(
+        self,
+        *,
+        process_id: str,
+        size: protocol.CommandExecTerminalSize,
+    ) -> EmptyResult:
+        """Resize the terminal attached to a running `command/exec` process.
+
+        This wraps the app-server `command/exec/resize` request and sends the
+        new terminal dimensions as `cols` and `rows`.
+        """
+        params = protocol.CommandExecResizeParams(processId=process_id, size=size)
+        return await self._rpc.request_typed("command/exec/resize", params, EmptyResult)
+
+    async def terminate_process(self, *, process_id: str) -> EmptyResult:
+        """Terminate a running `command/exec` process.
+
+        This wraps the app-server `command/exec/terminate` request for the
+        client-supplied process id.
+        """
+        params = protocol.CommandExecTerminateParams(processId=process_id)
+        return await self._rpc.request_typed("command/exec/terminate", params, EmptyResult)
+
 
 class AsyncExternalAgentConfigClient(_AsyncServiceClient):
     async def detect(
@@ -369,7 +428,10 @@ class AsyncWindowsSandboxClient(_AsyncServiceClient):
         mode: protocol.WindowsSandboxSetupMode,
         cwd: str | None = None,
     ) -> WindowsSandboxSetupStartResult:
-        params = protocol.WindowsSandboxSetupStartParams(cwd=cwd, mode=mode)
+        params = protocol.WindowsSandboxSetupStartParams(
+            cwd=protocol.AbsolutePathBuf(cwd) if cwd is not None else None,
+            mode=mode,
+        )
         return await self._rpc.request_typed(
             "windowsSandbox/setupStart",
             params,

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/_async_threads.py

@@ -41,9 +41,13 @@ _TURN_STREAM_NOTIFICATION_METHODS = {
     "turn/completed",
     "turn/diff/updated",
     "turn/plan/updated",
+    "hook/started",
+    "hook/completed",
     "thread/tokenUsage/updated",
     "item/started",
     "item/completed",
+    "item/autoApprovalReview/started",
+    "item/autoApprovalReview/completed",
     "item/agentMessage/delta",
     "item/plan/delta",
     "item/reasoning/summaryTextDelta",
@@ -235,15 +239,21 @@ class AsyncTurnStream:
         self._require_terminal_turn()
         return self._final_message
 
-    async def steer(self, input: TurnInput) -> TurnIdResult:
+    async def steer(
+        self,
+        input: TurnInput,
+        *,
+        responsesapi_client_metadata: Mapping[str, object] | None = None,
+    ) -> TurnIdResult:
         """Append additional user input to the in-flight turn."""
-        params = protocol.TurnSteerParams.model_validate(
-            {
-                "threadId": self.thread_id,
-                "expectedTurnId": self.turn_id,
-                "input": normalize_turn_input(input),
-            }
-        )
+        payload: dict[str, object] = {
+            "threadId": self.thread_id,
+            "expectedTurnId": self.turn_id,
+            "input": normalize_turn_input(input),
+        }
+        if responsesapi_client_metadata is not None:
+            payload["responsesapiClientMetadata"] = dict(responsesapi_client_metadata)
+        params = protocol.TurnSteerParams.model_validate(payload)
         return await self._thread._client.rpc.request_typed("turn/steer", params, TurnIdResult)
 
     async def interrupt(self) -> EmptyResult:

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/_protocol_helpers.py

@@ -12,7 +12,8 @@ from codex.app_server.models import GenericNotification, GenericServerRequest
 from codex.protocol import types as protocol
 
 type RequestHandler[RequestT: BaseModel] = Callable[[RequestT], object | Awaitable[object]]
-Notification = BaseModel
+type Notification = protocol.ServerNotificationValue | GenericNotification
+type ServerRequest = protocol.ServerRequestValue | GenericServerRequest
 
 
 def method_name(message: BaseModel) -> str:
@@ -123,7 +124,7 @@ def parse_notification(message: JsonObject, *, strict: bool) -> Notification:
         raise AppServerProtocolError(_notification_error_message(message)) from exc
 
 
-def parse_server_request(message: JsonObject, *, strict: bool) -> BaseModel:
+def parse_server_request(message: JsonObject, *, strict: bool) -> ServerRequest:
     method = message.get("method")
     try:
         return protocol.ServerRequest.model_validate(message).root
@@ -151,9 +152,10 @@ def _build_known_methods(*, root_model: type[BaseModel]) -> frozenset[str]:
     root_field = getattr(root_model, "model_fields", {}).get("root")
     if root_field is None:
         return frozenset()
+    annotation = _unwrap_type_alias(root_field.annotation)
     methods = {
         method
-        for candidate in get_args(root_field.annotation)
+        for candidate in get_args(annotation)
         if isinstance(candidate, type) and issubclass(candidate, BaseModel)
         for method in [_candidate_method_literal(candidate)]
         if method is not None
@@ -161,6 +163,10 @@ def _build_known_methods(*, root_model: type[BaseModel]) -> frozenset[str]:
     return frozenset(methods)
 
 
+def _unwrap_type_alias(annotation: object) -> object:
+    return getattr(annotation, "__value__", annotation)
+
+
 def _candidate_method_literal(candidate: type[BaseModel]) -> str | None:
     model_fields = getattr(candidate, "model_fields", None)
     if not isinstance(model_fields, dict) or "method" not in model_fields:

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/_sync_services.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Callable, Coroutine, Sequence
+from collections.abc import Callable, Coroutine, Mapping, Sequence
 from typing import Any, Protocol
 
 from codex.app_server._sync_support import _SyncRunner
@@ -25,6 +25,7 @@ from codex.app_server.models import (
     ModelInfo,
     ModelListResult,
     SkillsConfigWriteResult,
+    SkillsListEntry,
     SkillsListResult,
     WindowsSandboxSetupStartResult,
 )
@@ -75,15 +76,13 @@ class _AsyncSkillsClientLike(Protocol):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
-    ) -> list[protocol.SkillsListEntry]: ...
+    ) -> list[SkillsListEntry]: ...
 
     async def list_page(
         self,
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
     ) -> SkillsListResult: ...
 
     async def write_config(self, *, path: str, enabled: bool) -> SkillsConfigWriteResult: ...
@@ -184,10 +183,36 @@ class _AsyncCommandClientLike(Protocol):
         *,
         command: Sequence[str],
         cwd: str | None = None,
+        disable_output_cap: bool | None = None,
+        disable_timeout: bool | None = None,
+        env: Mapping[str, object | None] | None = None,
+        output_bytes_cap: int | None = None,
+        process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
+        size: protocol.CommandExecTerminalSize | None = None,
+        stream_stdin: bool | None = None,
+        stream_stdout_stderr: bool | None = None,
         timeout_ms: int | None = None,
+        tty: bool | None = None,
     ) -> CommandExecResult: ...
 
+    async def write_stdin(
+        self,
+        *,
+        process_id: str,
+        close_stdin: bool | None = None,
+        delta_base64: str | None = None,
+    ) -> EmptyResult: ...
+
+    async def resize_terminal(
+        self,
+        *,
+        process_id: str,
+        size: protocol.CommandExecTerminalSize,
+    ) -> EmptyResult: ...
+
+    async def terminate_process(self, *, process_id: str) -> EmptyResult: ...
+
 
 class _AsyncExternalAgentConfigClientLike(Protocol):
     async def detect(
@@ -311,13 +336,11 @@ class _SkillsClient(_SyncRunner):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
-    ) -> list[protocol.SkillsListEntry]:
+    ) -> list[SkillsListEntry]:
         return self._run(
             self._async_client.list(
                 cwds=cwds,
                 force_reload=force_reload,
-                per_cwd_extra_user_roots=per_cwd_extra_user_roots,
             )
         )
 
@@ -326,13 +349,11 @@ class _SkillsClient(_SyncRunner):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
     ) -> SkillsListResult:
         return self._run(
             self._async_client.list_page(
                 cwds=cwds,
                 force_reload=force_reload,
-                per_cwd_extra_user_roots=per_cwd_extra_user_roots,
             )
         )
 
@@ -529,20 +550,80 @@ class _CommandClient(_SyncRunner):
         *,
         command: Sequence[str],
         cwd: str | None = None,
+        disable_output_cap: bool | None = None,
+        disable_timeout: bool | None = None,
+        env: Mapping[str, object | None] | None = None,
+        output_bytes_cap: int | None = None,
+        process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
+        size: protocol.CommandExecTerminalSize | None = None,
+        stream_stdin: bool | None = None,
+        stream_stdout_stderr: bool | None = None,
         timeout_ms: int | None = None,
+        tty: bool | None = None,
     ) -> CommandExecResult:
         return self._run(
             self._async_client.execute(
                 command=command,
                 cwd=cwd,
+                disable_output_cap=disable_output_cap,
+                disable_timeout=disable_timeout,
+                env=env,
+                output_bytes_cap=output_bytes_cap,
+                process_id=process_id,
                 sandbox_policy=sandbox_policy,
+                size=size,
+                stream_stdin=stream_stdin,
+                stream_stdout_stderr=stream_stdout_stderr,
                 timeout_ms=timeout_ms,
+                tty=tty,
             )
         )
 
     exec = execute
 
+    def write_stdin(
+        self,
+        *,
+        process_id: str,
+        close_stdin: bool | None = None,
+        delta_base64: str | None = None,
+    ) -> EmptyResult:
+        """Write stdin bytes to a running `command/exec` process or close stdin.
+
+        This wraps the app-server `command/exec/write` request. `delta_base64`
+        is optional base64-encoded stdin data; `close_stdin` closes the
+        process stdin after the optional write.
+        """
+        return self._run(
+            self._async_client.write_stdin(
+                process_id=process_id,
+                close_stdin=close_stdin,
+                delta_base64=delta_base64,
+            )
+        )
+
+    def resize_terminal(
+        self,
+        *,
+        process_id: str,
+        size: protocol.CommandExecTerminalSize,
+    ) -> EmptyResult:
+        """Resize the terminal attached to a running `command/exec` process.
+
+        This wraps the app-server `command/exec/resize` request and sends the
+        new terminal dimensions as `cols` and `rows`.
+        """
+        return self._run(self._async_client.resize_terminal(process_id=process_id, size=size))
+
+    def terminate_process(self, *, process_id: str) -> EmptyResult:
+        """Terminate a running `command/exec` process.
+
+        This wraps the app-server `command/exec/terminate` request for the
+        client-supplied process id.
+        """
+        return self._run(self._async_client.terminate_process(process_id=process_id))
+
 
 class _ExternalAgentConfigClient(_SyncRunner):
     def __init__(

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/_sync_threads.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable, Collection, Coroutine
+from collections.abc import Callable, Collection, Coroutine, Mapping
 from typing import Any, Protocol, TypeVar
 
 from pydantic import BaseModel
@@ -45,7 +45,12 @@ class _AsyncTurnStreamLike(Protocol):
 
     def raise_for_terminal_status(self) -> None: ...
 
-    async def steer(self, input: TurnInput) -> TurnIdResult: ...
+    async def steer(
+        self,
+        input: TurnInput,
+        *,
+        responsesapi_client_metadata: Mapping[str, object] | None = None,
+    ) -> TurnIdResult: ...
 
     async def interrupt(self) -> EmptyResult: ...
 
@@ -217,8 +222,18 @@ class TurnStream(_SyncRunner):
     def raise_for_terminal_status(self) -> None:
         self._async_stream.raise_for_terminal_status()
 
-    def steer(self, input: TurnInput) -> TurnIdResult:
-        return self._run(self._async_stream.steer(input))
+    def steer(
+        self,
+        input: TurnInput,
+        *,
+        responsesapi_client_metadata: Mapping[str, object] | None = None,
+    ) -> TurnIdResult:
+        return self._run(
+            self._async_stream.steer(
+                input,
+                responsesapi_client_metadata=responsesapi_client_metadata,
+            )
+        )
 
     def interrupt(self) -> EmptyResult:
         return self._run(self._async_stream.interrupt())

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/models.py

@@ -71,6 +71,7 @@ DEFAULT_INPUT_MODALITIES: tuple[Literal["text", "image"], Literal["text", "image
 
 
 class ModelInfo(AppServerResultModel):
+    additional_speed_tiers: list[str] | None = Field(default_factory=list)
     availability_nux: ModelAvailabilityNux | None = None
     default_reasoning_effort: protocol.ReasoningEffort
     description: str
@@ -98,8 +99,34 @@ class AppListResult(AppServerResultModel):
     next_cursor: str | None = None
 
 
+class SkillInterface(AppServerResultModel):
+    display_name: str | None = None
+    short_description: str | None = None
+    icon_small: str | None = None
+    icon_large: str | None = None
+    brand_color: str | None = None
+    default_prompt: str | None = None
+
+
+class SkillInfo(AppServerResultModel):
+    name: str
+    description: str
+    dependencies: protocol.SkillDependencies | None = None
+    enabled: bool
+    path: str
+    scope: str
+    interface: SkillInterface | None = None
+    short_description: str | None = None
+
+
+class SkillsListEntry(AppServerResultModel):
+    cwd: str
+    skills: list[SkillInfo]
+    errors: list[protocol.SkillErrorInfo] = Field(default_factory=list)
+
+
 class SkillsListResult(AppServerResultModel):
-    data: list[protocol.SkillsListEntry]
+    data: list[SkillsListEntry]
 
 
 class SkillsConfigWriteResult(AppServerResultModel):
@@ -181,10 +208,12 @@ class ConfigWriteResult(AppServerResultModel):
 
 class ConfigRequirements(AppServerResultModel):
     allowed_approval_policies: list[protocol.AskForApproval] | None = None
+    allowed_approvals_reviewers: list[protocol.ApprovalsReviewer] | None = None
     allowed_sandbox_modes: list[protocol.SandboxMode] | None = None
-    allowed_web_search_modes: list[Literal["disabled", "cached", "live"]] | None = None
-    enforce_residency: Literal["us"] | None = None
-    feature_requirements: dict[str, bool] | None = None
+    allowed_web_search_modes: list[protocol.WebSearchMode] | None = None
+    enforce_residency: protocol.ResidencyRequirement | None = None
+    feature_requirements: dict[str, object] | None = None
+    network: protocol.NetworkRequirements | None = None
 
 
 class ConfigRequirementsReadResult(AppServerResultModel):

{codex_python-1.114.2 → codex_python-1.131.0}/codex/app_server/options.py

@@ -189,6 +189,10 @@ class AppServerTurnOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as turn/start approvalPolicy.",
     )
+    approvals_reviewer: protocol.ApprovalsReviewer | None = Field(
+        default=None,
+        description="Sent as turn/start approvalsReviewer.",
+    )
     collaboration_mode: protocol.CollaborationMode | None = Field(
         default=None,
         description="Sent as turn/start collaborationMode.",
@@ -216,6 +220,10 @@ class AppServerTurnOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as turn/start personality.",
     )
+    responsesapi_client_metadata: dict[str, object] | None = Field(
+        default=None,
+        description="Sent as turn/start responsesapiClientMetadata.",
+    )
     sandbox_policy: protocol.SandboxPolicy | None = Field(
         default=None,
         description="Sent as turn/start sandboxPolicy.",
@@ -249,6 +257,10 @@ class AppServerThreadStartOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/start approvalPolicy.",
     )
+    approvals_reviewer: protocol.ApprovalsReviewer | None = Field(
+        default=None,
+        description="Sent as thread/start approvalsReviewer.",
+    )
     base_instructions: str | None = Field(
         default=None,
         description="Sent as thread/start baseInstructions.",
@@ -321,6 +333,10 @@ class AppServerThreadStartOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/start serviceTier.",
     )
+    session_start_source: protocol.ThreadStartSource | None = Field(
+        default=None,
+        description="Sent as thread/start sessionStartSource.",
+    )
 
     def to_params(self) -> protocol.ThreadStartParams:
         return cast(
@@ -336,6 +352,10 @@ class AppServerThreadResumeOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/resume approvalPolicy.",
     )
+    approvals_reviewer: protocol.ApprovalsReviewer | None = Field(
+        default=None,
+        description="Sent as thread/resume approvalsReviewer.",
+    )
     base_instructions: str | None = Field(
         default=None,
         description="Sent as thread/resume baseInstructions.",
@@ -404,6 +424,10 @@ class AppServerThreadForkOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/fork approvalPolicy.",
     )
+    approvals_reviewer: protocol.ApprovalsReviewer | None = Field(
+        default=None,
+        description="Sent as thread/fork approvalsReviewer.",
+    )
     base_instructions: str | None = Field(
         default=None,
         description="Sent as thread/fork baseInstructions.",
@@ -420,6 +444,10 @@ class AppServerThreadForkOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/fork developerInstructions.",
     )
+    ephemeral: bool | None = Field(
+        default=None,
+        description="Sent as thread/fork ephemeral.",
+    )
     model: str | None = Field(
         default=None,
         description="Sent as thread/fork model.",
@@ -491,6 +519,10 @@ class AppServerThreadListOptions(_AppServerOptionsModel):
         default=None,
         description="Sent as thread/list sortKey.",
     )
+    sort_direction: protocol.SortDirection | None = Field(
+        default=None,
+        description="Sent as thread/list sortDirection.",
+    )
     source_kinds: list[protocol.ThreadSourceKind] | None = Field(
         default=None,
         description="Sent as thread/list sourceKinds.",