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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-python
-Version: 1.131.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.131.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.131.0"
+__version__ = "1.131.1"
 
 __all__ = [
     "Codex",

{codex_python-1.131.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.131.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.131.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."""

{codex_python-1.131.0 → codex_python-1.131.1}/crates/codex_native/Cargo.lock

@@ -20,7 +20,7 @@ dependencies = [
 
 [[package]]
 name = "codex_native"
-version = "1.131.0"
+version = "1.131.1"
 dependencies = [
  "pyo3",
 ]

{codex_python-1.131.0 → codex_python-1.131.1}/crates/codex_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codex_native"
-version = "1.131.0"
+version = "1.131.1"
 edition = "2021"
 
 [lib]