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

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

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

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

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

{codex_python-1.131.0 → codex_python-1.140.0}/codex/app_server/_async_client.py

@@ -14,6 +14,7 @@ from codex.app_server._async_services import (
     AsyncConfigClient,
     AsyncExternalAgentConfigClient,
     AsyncFeedbackClient,
+    AsyncFsClient,
     AsyncMcpServersClient,
     AsyncModelsClient,
     AsyncSkillsClient,
@@ -22,7 +23,7 @@ from codex.app_server._async_services import (
 from codex.app_server._async_threads import AsyncAppServerThread as AsyncAppServerThread
 from codex.app_server._async_threads import AsyncTurnStream as AsyncTurnStream
 from codex.app_server._async_threads import _ThreadClient
-from codex.app_server._protocol_helpers import RequestHandler
+from codex.app_server._protocol_helpers import Notification, RequestHandler
 from codex.app_server._session import _AsyncNotificationSubscription, _AsyncSession
 from codex.app_server.models import (
     InitializeResult,
@@ -107,6 +108,35 @@ class AsyncEventsClient:
     def subscribe(self, methods: Collection[str] | None = None) -> _AsyncNotificationSubscription:
         return self._session.subscribe_notifications(methods)
 
+    def subscribe_command_exec_output(self, process_id: str) -> _AsyncNotificationSubscription:
+        """Subscribe to `command/exec/outputDelta` notifications for one process id."""
+
+        def predicate(notification: Notification) -> bool:
+            return (
+                isinstance(notification, protocol.CommandExecOutputDeltaNotificationModel)
+                and notification.params.processId == process_id
+            )
+
+        return self._session.subscribe_notifications(
+            {"command/exec/outputDelta"},
+            predicate=predicate,
+        )
+
+    def subscribe_process_events(self, process_handle: str) -> _AsyncNotificationSubscription:
+        """Subscribe to `process/outputDelta` and `process/exited` for one process handle."""
+
+        def predicate(notification: Notification) -> bool:
+            if isinstance(notification, protocol.ProcessOutputDeltaNotificationModel):
+                return notification.params.processHandle == process_handle
+            if isinstance(notification, protocol.ProcessExitedNotificationModel):
+                return notification.params.processHandle == process_handle
+            return False
+
+        return self._session.subscribe_notifications(
+            {"process/outputDelta", "process/exited"},
+            predicate=predicate,
+        )
+
 
 class AsyncAppServerClient:
     """Async client for `codex app-server`."""
@@ -122,7 +152,8 @@ class AsyncAppServerClient:
         self.events = AsyncEventsClient(self._session)
         self.models = AsyncModelsClient(self.rpc)
         self.apps = AsyncAppsClient(self.rpc)
-        self.skills = AsyncSkillsClient(self.rpc)
+        self.fs = AsyncFsClient(self.rpc)
+        self.skills = AsyncSkillsClient(self.rpc, self.fs)
         self.account = AsyncAccountClient(self.rpc)
         self.config = AsyncConfigClient(self.rpc)
         self.mcp_servers = AsyncMcpServersClient(self.rpc)

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

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import base64
 from collections.abc import Mapping, Sequence
 from typing import Any, Protocol, TypeVar
 
 from pydantic import BaseModel
 
+from codex.app_server._payloads import skill_input
 from codex.app_server.models import (
     AccountCancelLoginResult,
     AccountRateLimitsResult,
@@ -49,6 +51,16 @@ class _AsyncServiceClient:
         self._rpc = rpc
 
 
+def _skill_markdown_path(directory: str) -> str:
+    if directory == "":
+        raise ValueError("Skill directory cannot be empty.")
+    if directory.endswith("/") or directory.endswith("\\"):
+        return f"{directory}SKILL.md"
+    if "\\" in directory and "/" not in directory:
+        return f"{directory}\\SKILL.md"
+    return f"{directory}/SKILL.md"
+
+
 class AsyncModelsClient(_AsyncServiceClient):
     async def list(
         self,
@@ -107,7 +119,50 @@ class AsyncAppsClient(_AsyncServiceClient):
         return await self._rpc.request_typed("app/list", params, AppListResult)
 
 
+class AsyncFsClient(_AsyncServiceClient):
+    async def create_directory(
+        self,
+        *,
+        path: str,
+        recursive: bool | None = True,
+    ) -> protocol.FsCreateDirectoryResponse:
+        params = protocol.FsCreateDirectoryParams(
+            path=protocol.AbsolutePathBuf(path),
+            recursive=recursive,
+        )
+        return await self._rpc.request_typed(
+            "fs/createDirectory",
+            params,
+            protocol.FsCreateDirectoryResponse,
+        )
+
+    async def write_file(
+        self,
+        *,
+        path: str,
+        data: str | bytes,
+        encoding: str = "utf-8",
+    ) -> protocol.FsWriteFileResponse:
+        raw_data = data.encode(encoding) if isinstance(data, str) else data
+        params = protocol.FsWriteFileParams(
+            path=protocol.AbsolutePathBuf(path),
+            dataBase64=base64.b64encode(raw_data).decode("ascii"),
+        )
+        return await self._rpc.request_typed(
+            "fs/writeFile",
+            params,
+            protocol.FsWriteFileResponse,
+        )
+
+
 class AsyncSkillsClient(_AsyncServiceClient):
+    def __init__(self, rpc: _TypedRpcClient, fs: AsyncFsClient) -> None:
+        super().__init__(rpc)
+        self._fs = fs
+
+    def input(self, *, name: str, path: str) -> protocol.SkillUserInput:
+        return skill_input(name=name, path=path)
+
     async def list(
         self,
         *,
@@ -133,6 +188,9 @@ class AsyncSkillsClient(_AsyncServiceClient):
         )
         return await self._rpc.request_typed("skills/list", params, SkillsListResult)
 
+    async def reload(self, *, cwds: Sequence[str] | None = None) -> Sequence[SkillsListEntry]:
+        return await self.list(cwds=cwds, force_reload=True)
+
     async def write_config(self, *, path: str, enabled: bool) -> SkillsConfigWriteResult:
         params = protocol.SkillsConfigWriteParams(
             path=protocol.AbsolutePathBuf(path),
@@ -140,6 +198,20 @@ class AsyncSkillsClient(_AsyncServiceClient):
         )
         return await self._rpc.request_typed("skills/config/write", params, SkillsConfigWriteResult)
 
+    async def write_skill(
+        self,
+        *,
+        name: str,
+        directory: str,
+        instructions: str | bytes,
+        reload_cwds: Sequence[str] | None = None,
+    ) -> protocol.SkillUserInput:
+        skill_path = _skill_markdown_path(directory)
+        await self._fs.create_directory(path=directory, recursive=True)
+        await self._fs.write_file(path=skill_path, data=instructions)
+        await self.reload(cwds=reload_cwds)
+        return self.input(name=name, path=skill_path)
+
 
 class AsyncAccountClient(_AsyncServiceClient):
     async def read(self, *, refresh_token: bool | None = None) -> AccountReadResult:
@@ -324,6 +396,7 @@ class AsyncCommandClient(_AsyncServiceClient):
         disable_timeout: bool | None = None,
         env: Mapping[str, object | None] | None = None,
         output_bytes_cap: int | None = None,
+        permission_profile: str | None = None,
         process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
         size: protocol.CommandExecTerminalSize | None = None,
@@ -339,6 +412,7 @@ class AsyncCommandClient(_AsyncServiceClient):
             disableTimeout=disable_timeout,
             env=dict(env) if env is not None else None,
             outputBytesCap=output_bytes_cap,
+            permissionProfile=permission_profile,
             processId=process_id,
             sandboxPolicy=sandbox_policy,
             size=size,

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

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Callable, Collection, Mapping
+from collections.abc import Callable, Collection, Mapping, Sequence
 from dataclasses import dataclass
 from typing import Protocol, TypeVar, cast
 
@@ -37,9 +37,11 @@ _ModelT = TypeVar("_ModelT", bound=BaseModel)
 DEFAULT_REVIEW_DELIVERY = protocol.ReviewDelivery("inline")
 
 _TURN_STREAM_NOTIFICATION_METHODS = {
+    "error",
     "turn/started",
     "turn/completed",
     "turn/diff/updated",
+    "turn/moderationMetadata",
     "turn/plan/updated",
     "hook/started",
     "hook/completed",
@@ -54,6 +56,7 @@ _TURN_STREAM_NOTIFICATION_METHODS = {
     "item/reasoning/summaryPartAdded",
     "item/reasoning/textDelta",
     "item/commandExecution/outputDelta",
+    "item/commandExecution/terminalInteraction",
     "item/fileChange/outputDelta",
     "serverRequest/resolved",
 }
@@ -132,6 +135,7 @@ class AsyncTurnStream:
         self.usage: protocol.ThreadTokenUsage | None = None
         self._item_index: dict[str, int] = {}
         self._text_deltas: list[str] = []
+        self._retryable_error_notifications: list[protocol.ErrorNotificationModel] = []
         self._done = False
         self._closed = False
 
@@ -188,6 +192,16 @@ class AsyncTurnStream:
             raise StopAsyncIteration
         notification = await self._subscription.next()
         self._apply(notification)
+        if isinstance(notification, protocol.ErrorNotificationModel):
+            if not notification.params.willRetry:
+                self._done = True
+                await self.close()
+                error = notification.params.error
+                message = error.message
+                if error.additionalDetails is not None and error.additionalDetails != "":
+                    message = f"{message}: {error.additionalDetails}"
+                raise AppServerTurnError(message)
+            self._retryable_error_notifications.append(notification)
         if isinstance(notification, protocol.TurnCompletedNotificationModel):
             self._done = True
         return notification
@@ -244,12 +258,13 @@ class AsyncTurnStream:
         input: TurnInput,
         *,
         responsesapi_client_metadata: Mapping[str, object] | None = None,
+        skills: Sequence[protocol.SkillUserInput] | None = None,
     ) -> TurnIdResult:
         """Append additional user input to the in-flight turn."""
         payload: dict[str, object] = {
             "threadId": self.thread_id,
             "expectedTurnId": self.turn_id,
-            "input": normalize_turn_input(input),
+            "input": normalize_turn_input(input, skills=skills),
         }
         if responsesapi_client_metadata is not None:
             payload["responsesapiClientMetadata"] = dict(responsesapi_client_metadata)
@@ -274,6 +289,18 @@ class AsyncTurnStream:
         """Return the streamed agent text deltas received so far."""
         return tuple(self._text_deltas)
 
+    @property
+    def retryable_error_notifications(self) -> tuple[protocol.ErrorNotificationModel, ...]:
+        """Return retryable turn error notifications received so far."""
+        return tuple(self._retryable_error_notifications)
+
+    @property
+    def retryable_errors(self) -> tuple[protocol.TurnError, ...]:
+        """Return retryable turn errors received so far."""
+        return tuple(
+            notification.params.error for notification in self._retryable_error_notifications
+        )
+
     def _apply(self, notification: Notification) -> None:
         self._apply_text_delta(notification)
         self._apply_token_usage(notification)
@@ -391,11 +418,13 @@ class AsyncAppServerThread:
         self,
         input: TurnInput,
         options: AppServerTurnOptions | None = None,
+        *,
+        skills: Sequence[protocol.SkillUserInput] | None = None,
     ) -> AsyncTurnStream:
         """Start a turn and return the protocol-native notification stream."""
         payload = (options or AppServerTurnOptions()).to_params(
             thread_id=self.id,
-            input=normalize_turn_input(input),
+            input=normalize_turn_input(input, skills=skills),
         )
         return await AsyncTurnStream.start(self, payload)
 
@@ -403,8 +432,10 @@ class AsyncAppServerThread:
         self,
         input: TurnInput,
         options: AppServerTurnOptions | None = None,
+        *,
+        skills: Sequence[protocol.SkillUserInput] | None = None,
     ) -> str:
-        stream = await self.run(input, options)
+        stream = await self.run(input, options, skills=skills)
         await stream.wait()
         stream.raise_for_terminal_status()
         return stream.final_text
@@ -413,8 +444,10 @@ class AsyncAppServerThread:
         self,
         input: TurnInput,
         options: AppServerTurnOptions | None = None,
+        *,
+        skills: Sequence[protocol.SkillUserInput] | None = None,
     ) -> object:
-        stream = await self.run(input, options)
+        stream = await self.run(input, options, skills=skills)
         await stream.wait()
         stream.raise_for_terminal_status()
         return stream.final_json()
@@ -424,6 +457,8 @@ class AsyncAppServerThread:
         input: TurnInput,
         model_type: type[_ModelT],
         options: AppServerTurnOptions | None = None,
+        *,
+        skills: Sequence[protocol.SkillUserInput] | None = None,
     ) -> _ModelT:
         """Run a turn and validate the final assistant text with `model_type`."""
         stream = await self.run(
@@ -433,6 +468,7 @@ class AsyncAppServerThread:
                 model_type,
                 owner="AppServerThread.run_model()",
             ),
+            skills=skills,
         )
         await stream.wait()
         stream.raise_for_terminal_status()

codex_python-1.140.0/codex/app_server/_payloads.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, cast
+
+from pydantic import BaseModel
+
+from codex.app_server._types import JsonObject
+from codex.protocol import types as protocol
+
+InputItem = (
+    str
+    | Mapping[str, Any]
+    | protocol.UserInput
+    | protocol.TextUserInput
+    | protocol.ImageUserInput
+    | protocol.LocalImageUserInput
+    | protocol.SkillUserInput
+    | protocol.MentionUserInput
+)
+TurnInput = InputItem | Sequence[InputItem]
+
+type ParamsModel = BaseModel
+
+
+def serialize_value(value: object) -> object:
+    if isinstance(value, BaseModel):
+        return value.model_dump(
+            mode="json",
+            by_alias=True,
+            exclude_none=True,
+            exclude_unset=True,
+        )
+    if isinstance(value, type) and issubclass(value, BaseModel):
+        return value.model_json_schema()
+    if isinstance(value, list):
+        return [serialize_value(item) for item in value]
+    if isinstance(value, tuple):
+        return [serialize_value(item) for item in value]
+    if isinstance(value, Mapping):
+        return {key: serialize_value(item) for key, item in value.items()}
+    return value
+
+
+def normalize_input_item(item: InputItem) -> JsonObject:
+    if isinstance(item, str):
+        return {"type": "text", "text": item}
+    serialized = serialize_value(item)
+    if not isinstance(serialized, dict):
+        raise TypeError(f"Input item must serialize to an object, got {type(serialized).__name__}")
+    return cast(JsonObject, serialized)
+
+
+def skill_input(*, name: str, path: str) -> protocol.SkillUserInput:
+    if name == "":
+        raise ValueError("Skill name cannot be empty.")
+    if name.startswith("$"):
+        raise ValueError("Skill name should not include the '$' activation marker.")
+    if any(character.isspace() for character in name):
+        raise ValueError("Skill name cannot contain whitespace.")
+    if "/" in name or "\\" in name:
+        raise ValueError("Skill name cannot contain path separators.")
+    if path == "":
+        raise ValueError("Skill path cannot be empty.")
+    return protocol.SkillUserInput(
+        type=protocol.SkillUserInputType("skill"),
+        name=name,
+        path=path,
+    )
+
+
+def _add_skill_markers(
+    items: list[JsonObject],
+    skills: Sequence[protocol.SkillUserInput],
+) -> list[JsonObject]:
+    if not skills:
+        return items
+    markers = " ".join(f"${skill.name}" for skill in skills)
+    for item in items:
+        if item.get("type") != "text":
+            continue
+        text = item.get("text")
+        if isinstance(text, str):
+            item["text"] = f"{markers}\n\n{text}"
+            return items
+    return [{"type": "text", "text": markers}, *items]
+
+
+def normalize_turn_input(
+    value: TurnInput,
+    *,
+    skills: Sequence[protocol.SkillUserInput] | None = None,
+) -> list[JsonObject]:
+    if isinstance(value, str):
+        items = [{"type": "text", "text": value}]
+    elif isinstance(value, Sequence):
+        items = [normalize_input_item(item) for item in value]
+    else:
+        items = [normalize_input_item(value)]
+    if skills is None:
+        return items
+    return _add_skill_markers(items, skills) + [normalize_input_item(skill) for skill in skills]

{codex_python-1.131.0 → codex_python-1.140.0}/codex/app_server/_sync_client.py

@@ -21,6 +21,7 @@ from codex.app_server._sync_services import (
     _ConfigClient,
     _ExternalAgentConfigClient,
     _FeedbackClient,
+    _FsClient,
     _McpServersClient,
     _ModelsClient,
     _SkillsClient,
@@ -240,6 +241,7 @@ class AppServerClient(_SyncRunner):
         self.mcp_servers = _McpServersClient(async_client.mcp_servers, self._run)
         self.feedback = _FeedbackClient(async_client.feedback, self._run)
         self.command = _CommandClient(async_client.command, self._run)
+        self.fs = _FsClient(async_client.fs, self._run)
         self.external_agent_config = _ExternalAgentConfigClient(
             async_client.external_agent_config,
             self._run,

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

@@ -71,6 +71,8 @@ class _AsyncAppsClientLike(Protocol):
 
 
 class _AsyncSkillsClientLike(Protocol):
+    def input(self, *, name: str, path: str) -> protocol.SkillUserInput: ...
+
     async def list(
         self,
         *,
@@ -85,8 +87,36 @@ class _AsyncSkillsClientLike(Protocol):
         force_reload: bool | None = None,
     ) -> SkillsListResult: ...
 
+    async def reload(self, *, cwds: Sequence[str] | None = None) -> Sequence[SkillsListEntry]: ...
+
     async def write_config(self, *, path: str, enabled: bool) -> SkillsConfigWriteResult: ...
 
+    async def write_skill(
+        self,
+        *,
+        name: str,
+        directory: str,
+        instructions: str | bytes,
+        reload_cwds: Sequence[str] | None = None,
+    ) -> protocol.SkillUserInput: ...
+
+
+class _AsyncFsClientLike(Protocol):
+    async def create_directory(
+        self,
+        *,
+        path: str,
+        recursive: bool | None = True,
+    ) -> protocol.FsCreateDirectoryResponse: ...
+
+    async def write_file(
+        self,
+        *,
+        path: str,
+        data: str | bytes,
+        encoding: str = "utf-8",
+    ) -> protocol.FsWriteFileResponse: ...
+
 
 class _AsyncAccountClientLike(Protocol):
     async def read(self, *, refresh_token: bool | None = None) -> AccountReadResult: ...
@@ -187,6 +217,7 @@ class _AsyncCommandClientLike(Protocol):
         disable_timeout: bool | None = None,
         env: Mapping[str, object | None] | None = None,
         output_bytes_cap: int | None = None,
+        permission_profile: str | None = None,
         process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
         size: protocol.CommandExecTerminalSize | None = None,
@@ -331,6 +362,9 @@ class _SkillsClient(_SyncRunner):
         super().__init__(runner)
         self._async_client = async_client
 
+    def input(self, *, name: str, path: str) -> protocol.SkillUserInput:
+        return self._async_client.input(name=name, path=path)
+
     def list(
         self,
         *,
@@ -357,9 +391,56 @@ class _SkillsClient(_SyncRunner):
             )
         )
 
+    def reload(self, *, cwds: Sequence[str] | None = None) -> Sequence[SkillsListEntry]:
+        return self._run(self._async_client.reload(cwds=cwds))
+
     def write_config(self, *, path: str, enabled: bool) -> SkillsConfigWriteResult:
         return self._run(self._async_client.write_config(path=path, enabled=enabled))
 
+    def write_skill(
+        self,
+        *,
+        name: str,
+        directory: str,
+        instructions: str | bytes,
+        reload_cwds: Sequence[str] | None = None,
+    ) -> protocol.SkillUserInput:
+        return self._run(
+            self._async_client.write_skill(
+                name=name,
+                directory=directory,
+                instructions=instructions,
+                reload_cwds=reload_cwds,
+            )
+        )
+
+
+class _FsClient(_SyncRunner):
+    def __init__(
+        self,
+        async_client: _AsyncFsClientLike,
+        runner: Callable[[Coroutine[Any, Any, Any]], Any],
+    ) -> None:
+        super().__init__(runner)
+        self._async_client = async_client
+
+    def create_directory(
+        self,
+        *,
+        path: str,
+        recursive: bool | None = True,
+    ) -> protocol.FsCreateDirectoryResponse:
+        return self._run(self._async_client.create_directory(path=path, recursive=recursive))
+
+    def write_file(
+        self,
+        *,
+        path: str,
+        data: str | bytes,
+        encoding: str = "utf-8",
+    ) -> protocol.FsWriteFileResponse:
+        return self._run(self._async_client.write_file(path=path, data=data, encoding=encoding))
+
 
 class _AccountClient(_SyncRunner):
     def __init__(
@@ -554,6 +635,7 @@ class _CommandClient(_SyncRunner):
         disable_timeout: bool | None = None,
         env: Mapping[str, object | None] | None = None,
         output_bytes_cap: int | None = None,
+        permission_profile: str | None = None,
         process_id: str | None = None,
         sandbox_policy: protocol.SandboxPolicy | None = None,
         size: protocol.CommandExecTerminalSize | None = None,
@@ -570,6 +652,7 @@ class _CommandClient(_SyncRunner):
                 disable_timeout=disable_timeout,
                 env=env,
                 output_bytes_cap=output_bytes_cap,
+                permission_profile=permission_profile,
                 process_id=process_id,
                 sandbox_policy=sandbox_policy,
                 size=size,