codex-python 1.122.0__tar.gz → 1.131.1__tar.gz

{codex_python-1.122.0 → codex_python-1.131.1}/PKG-INFO

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

{codex_python-1.122.0 → codex_python-1.131.1}/codex/__init__.py

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

{codex_python-1.122.0 → codex_python-1.131.1}/codex/app_server/_async_client.py

@@ -22,7 +22,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 +107,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`."""

{codex_python-1.122.0 → codex_python-1.131.1}/codex/app_server/_async_services.py

@@ -113,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[SkillsListEntry]:
         return (
             await self.list_page(
                 cwds=cwds,
                 force_reload=force_reload,
-                per_cwd_extra_user_roots=per_cwd_extra_user_roots,
             )
         ).data
 
@@ -128,14 +126,10 @@ 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)
 

{codex_python-1.122.0 → codex_python-1.131.1}/codex/app_server/_async_threads.py

@@ -37,6 +37,7 @@ _ModelT = TypeVar("_ModelT", bound=BaseModel)
 DEFAULT_REVIEW_DELIVERY = protocol.ReviewDelivery("inline")
 
 _TURN_STREAM_NOTIFICATION_METHODS = {
+    "error",
     "turn/started",
     "turn/completed",
     "turn/diff/updated",
@@ -54,6 +55,7 @@ _TURN_STREAM_NOTIFICATION_METHODS = {
     "item/reasoning/summaryPartAdded",
     "item/reasoning/textDelta",
     "item/commandExecution/outputDelta",
+    "item/commandExecution/terminalInteraction",
     "item/fileChange/outputDelta",
     "serverRequest/resolved",
 }
@@ -132,6 +134,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 +191,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
@@ -274,6 +287,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)

{codex_python-1.122.0 → codex_python-1.131.1}/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.122.0 → codex_python-1.131.1}/codex/app_server/_sync_services.py

@@ -76,7 +76,6 @@ class _AsyncSkillsClientLike(Protocol):
         *,
         cwds: Sequence[str] | None = None,
         force_reload: bool | None = None,
-        per_cwd_extra_user_roots: Sequence[protocol.SkillsListExtraRootsForCwd] | None = None,
     ) -> list[SkillsListEntry]: ...
 
     async def list_page(
@@ -84,7 +83,6 @@ class _AsyncSkillsClientLike(Protocol):
         *,
         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: ...
@@ -338,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[SkillsListEntry]:
         return self._run(
             self._async_client.list(
                 cwds=cwds,
                 force_reload=force_reload,
-                per_cwd_extra_user_roots=per_cwd_extra_user_roots,
             )
         )
 
@@ -353,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,
             )
         )
 

{codex_python-1.122.0 → codex_python-1.131.1}/codex/app_server/_sync_threads.py

@@ -25,6 +25,10 @@ class _AsyncEventsClientLike(Protocol):
         methods: Collection[str] | None = None,
     ) -> _AsyncNotificationSubscription: ...
 
+    def subscribe_command_exec_output(self, process_id: str) -> _AsyncNotificationSubscription: ...
+
+    def subscribe_process_events(self, process_handle: str) -> _AsyncNotificationSubscription: ...
+
 
 class _AsyncTurnStreamLike(Protocol):
     initial_turn: protocol.Turn
@@ -157,6 +161,20 @@ class EventsClient(_SyncRunner):
             self._run,
         )
 
+    def subscribe_command_exec_output(self, process_id: str) -> NotificationSubscription:
+        """Subscribe to `command/exec/outputDelta` notifications for one process id."""
+        return NotificationSubscription(
+            self._async_events.subscribe_command_exec_output(process_id),
+            self._run,
+        )
+
+    def subscribe_process_events(self, process_handle: str) -> NotificationSubscription:
+        """Subscribe to `process/outputDelta` and `process/exited` for one process handle."""
+        return NotificationSubscription(
+            self._async_events.subscribe_process_events(process_handle),
+            self._run,
+        )
+
 
 class TurnStream(_SyncRunner):
     """Synchronous iterator over protocol-native notifications for a single turn."""