chore(app-server): update Codex protocol to 0.122 (#11)

Author: gersmann

.github/workflows/ci.yml

@@ -69,7 +69,7 @@ jobs:
       - name: Fetch bundled codex binary for integration test
         if: ${{ steps.integration.outputs.enabled == 'true' }}
         env:
-          CODEX_BINARY_RELEASE_TAG: ${{ vars.CODEX_BINARY_RELEASE_TAG || 'latest' }}
+          CODEX_BINARY_RELEASE_TAG: ${{ vars.CODEX_BINARY_RELEASE_TAG || 'rust-v0.122.0' }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           set -euo pipefail

.github/workflows/release-published.yml

@@ -243,7 +243,7 @@ jobs:
       - name: Fetch bundled codex binaries
         shell: bash
         env:
-          CODEX_BINARY_RELEASE_TAG: ${{ vars.CODEX_BINARY_RELEASE_TAG || 'latest' }}
+          CODEX_BINARY_RELEASE_TAG: ${{ vars.CODEX_BINARY_RELEASE_TAG || 'rust-v0.122.0' }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           set -euo pipefail

codex/app_server/_async_services.py

@@ -26,6 +26,7 @@
     ModelInfo,
     ModelListResult,
     SkillsConfigWriteResult,
+    SkillsListEntry,
     SkillsListResult,
     WindowsSandboxSetupStartResult,
 )
@@ -113,7 +114,7 @@ async def list(
         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,
@@ -139,7 +140,10 @@ async def list_page(
         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 +326,80 @@ async def execute(
         *,
         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 +434,10 @@ async def setup_start(
         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/app_server/_async_threads.py

@@ -41,9 +41,13 @@
     "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 @@ def final_message(self) -> protocol.AgentMessageThreadItem | None:
         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/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 @@
     ModelInfo,
     ModelListResult,
     SkillsConfigWriteResult,
+    SkillsListEntry,
     SkillsListResult,
     WindowsSandboxSetupStartResult,
 )
@@ -76,7 +77,7 @@ async def list(
         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,
@@ -184,10 +185,36 @@ async def execute(
         *,
         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(
@@ -312,7 +339,7 @@ def list(
         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,
@@ -529,20 +556,80 @@ def execute(
         *,
         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/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 @@ def final_model(self, model_type: type[_ModelT]) -> _ModelT: ...
 
     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 @@ def collect(self) -> TurnStream:
     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())